Model.hs

-- Note: this is an automatically generated file. Do not edit.

-- | Term encoders for hydra.pg.model

module Hydra.Pg.Encode.Model where

import qualified Hydra.Core.Encode.Model as EncodeModel
import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps
import qualified Hydra.Core.Model as CoreModel
import qualified Hydra.Pg.Model as PgModel
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | Encoder for hydra.pg.model.AdjacentEdge
adjacentEdge :: (t0 -> CoreModel.Term) -> PgModel.AdjacentEdge t0 -> CoreModel.Term
adjacentEdge v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (edgeLabel (PgModel.adjacentEdgeLabel x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (v (PgModel.adjacentEdgeId x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (v (PgModel.adjacentEdgeVertex x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap propertyKey v m)) (PgModel.adjacentEdgeProperties x))}]})

-- | Encoder for hydra.pg.model.Direction
direction :: PgModel.Direction -> CoreModel.Term
direction x =
    case x of
      PgModel.DirectionOut -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = CoreModel.TermUnit}})
      PgModel.DirectionIn -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = CoreModel.TermUnit}})
      PgModel.DirectionBoth -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "both"),
          CoreModel.fieldTerm = CoreModel.TermUnit}})
      PgModel.DirectionUndirected -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "undirected"),
          CoreModel.fieldTerm = CoreModel.TermUnit}})

-- | Encoder for hydra.pg.model.Edge
edge :: (t0 -> CoreModel.Term) -> PgModel.Edge t0 -> CoreModel.Term
edge v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (edgeLabel (PgModel.edgeLabel x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (v (PgModel.edgeId x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (v (PgModel.edgeOut x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (v (PgModel.edgeIn x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap propertyKey v m)) (PgModel.edgeProperties x))}]})

-- | Encoder for hydra.pg.model.EdgeLabel
edgeLabel :: PgModel.EdgeLabel -> CoreModel.Term
edgeLabel x =
    CoreModel.TermWrap (CoreModel.WrappedTerm {
      CoreModel.wrappedTermTypeName = (CoreModel.Name "hydra.pg.model.EdgeLabel"),
      CoreModel.wrappedTermBody = ((\x2 -> CoreModel.TermLiteral (CoreModel.LiteralString x2)) (PgModel.unEdgeLabel x))})

-- | Encoder for hydra.pg.model.EdgeType
edgeType :: (t0 -> CoreModel.Term) -> PgModel.EdgeType t0 -> CoreModel.Term
edgeType t x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (edgeLabel (PgModel.edgeTypeLabel x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (t (PgModel.edgeTypeId x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (vertexLabel (PgModel.edgeTypeOut x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (vertexLabel (PgModel.edgeTypeIn x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (propertyType t) xs)) (PgModel.edgeTypeProperties x))}]})

-- | Encoder for hydra.pg.model.Element
element :: (t0 -> CoreModel.Term) -> PgModel.Element t0 -> CoreModel.Term
element v x =
    case x of
      PgModel.ElementVertex v0 -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Element"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (vertex v v0)}})
      PgModel.ElementEdge v0 -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Element"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edge"),
          CoreModel.fieldTerm = (edge v v0)}})

-- | Encoder for hydra.pg.model.ElementKind
elementKind :: PgModel.ElementKind -> CoreModel.Term
elementKind x =
    case x of
      PgModel.ElementKindVertex -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementKind"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = CoreModel.TermUnit}})
      PgModel.ElementKindEdge -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementKind"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edge"),
          CoreModel.fieldTerm = CoreModel.TermUnit}})

-- | Encoder for hydra.pg.model.ElementTree
elementTree :: (t0 -> CoreModel.Term) -> PgModel.ElementTree t0 -> CoreModel.Term
elementTree v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (element v (PgModel.elementTreeSelf x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (elementTree v) xs)) (PgModel.elementTreeDependencies x))}]})

-- | Encoder for hydra.pg.model.ElementType
elementType :: (t0 -> CoreModel.Term) -> PgModel.ElementType t0 -> CoreModel.Term
elementType t x =
    case x of
      PgModel.ElementTypeVertex v0 -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementType"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (vertexType t v0)}})
      PgModel.ElementTypeEdge v0 -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementType"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edge"),
          CoreModel.fieldTerm = (edgeType t v0)}})

-- | Encoder for hydra.pg.model.ElementTypeTree
elementTypeTree :: (t0 -> CoreModel.Term) -> PgModel.ElementTypeTree t0 -> CoreModel.Term
elementTypeTree t x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (elementType t (PgModel.elementTypeTreeSelf x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (elementTypeTree t) xs)) (PgModel.elementTypeTreeDependencies x))}]})

-- | Encoder for hydra.pg.model.Graph
graph :: Ord t0 => ((t0 -> CoreModel.Term) -> PgModel.Graph t0 -> CoreModel.Term)
graph v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap v (vertex v) m)) (PgModel.graphVertices x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap v (edge v) m)) (PgModel.graphEdges x))}]})

-- | Encoder for hydra.pg.model.GraphSchema
graphSchema :: (t0 -> CoreModel.Term) -> PgModel.GraphSchema t0 -> CoreModel.Term
graphSchema t x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap vertexLabel (vertexType t) m)) (PgModel.graphSchemaVertices x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap edgeLabel (edgeType t) m)) (PgModel.graphSchemaEdges x))}]})

-- | Encoder for hydra.pg.model.Label
label :: PgModel.Label -> CoreModel.Term
label x =
    case x of
      PgModel.LabelVertex v0 -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Label"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (vertexLabel v0)}})
      PgModel.LabelEdge v0 -> CoreModel.TermInject (CoreModel.Injection {
        CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Label"),
        CoreModel.injectionField = CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edge"),
          CoreModel.fieldTerm = (edgeLabel v0)}})

-- | Encoder for hydra.pg.model.LazyGraph
lazyGraph :: (t0 -> CoreModel.Term) -> PgModel.LazyGraph t0 -> CoreModel.Term
lazyGraph v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (vertex v) xs)) (PgModel.lazyGraphVertices x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (edge v) xs)) (PgModel.lazyGraphEdges x))}]})

-- | Encoder for hydra.pg.model.Property
property :: (t0 -> CoreModel.Term) -> PgModel.Property t0 -> CoreModel.Term
property v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Property"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (propertyKey (PgModel.propertyKey x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (v (PgModel.propertyValue x))}]})

-- | Encoder for hydra.pg.model.PropertyKey
propertyKey :: PgModel.PropertyKey -> CoreModel.Term
propertyKey x =
    CoreModel.TermWrap (CoreModel.WrappedTerm {
      CoreModel.wrappedTermTypeName = (CoreModel.Name "hydra.pg.model.PropertyKey"),
      CoreModel.wrappedTermBody = ((\x2 -> CoreModel.TermLiteral (CoreModel.LiteralString x2)) (PgModel.unPropertyKey x))})

-- | Encoder for hydra.pg.model.PropertyType
propertyType :: (t0 -> CoreModel.Term) -> PgModel.PropertyType t0 -> CoreModel.Term
propertyType t x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (propertyKey (PgModel.propertyTypeKey x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (t (PgModel.propertyTypeValue x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "required"),
          CoreModel.fieldTerm = ((\x2 -> CoreModel.TermLiteral (CoreModel.LiteralBoolean x2)) (PgModel.propertyTypeRequired x))}]})

-- | Encoder for hydra.pg.model.Vertex
vertex :: (t0 -> CoreModel.Term) -> PgModel.Vertex t0 -> CoreModel.Term
vertex v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (vertexLabel (PgModel.vertexLabel x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (v (PgModel.vertexId x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = ((\m -> CoreModel.TermMap (Maps.bimap propertyKey v m)) (PgModel.vertexProperties x))}]})

-- | Encoder for hydra.pg.model.VertexLabel
vertexLabel :: PgModel.VertexLabel -> CoreModel.Term
vertexLabel x =
    CoreModel.TermWrap (CoreModel.WrappedTerm {
      CoreModel.wrappedTermTypeName = (CoreModel.Name "hydra.pg.model.VertexLabel"),
      CoreModel.wrappedTermBody = ((\x2 -> CoreModel.TermLiteral (CoreModel.LiteralString x2)) (PgModel.unVertexLabel x))})

-- | Encoder for hydra.pg.model.VertexType
vertexType :: (t0 -> CoreModel.Term) -> PgModel.VertexType t0 -> CoreModel.Term
vertexType t x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (vertexLabel (PgModel.vertexTypeLabel x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (t (PgModel.vertexTypeId x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (propertyType t) xs)) (PgModel.vertexTypeProperties x))}]})

-- | Encoder for hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdges :: (t0 -> CoreModel.Term) -> PgModel.VertexWithAdjacentEdges t0 -> CoreModel.Term
vertexWithAdjacentEdges v x =
    CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (vertex v (PgModel.vertexWithAdjacentEdgesVertex x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "ins"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (adjacentEdge v) xs)) (PgModel.vertexWithAdjacentEdgesIns x))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "outs"),
          CoreModel.fieldTerm = ((\xs -> CoreModel.TermList (Lists.map (adjacentEdge v) xs)) (PgModel.vertexWithAdjacentEdgesOuts x))}]})