module Data.RDF.Query (
sortTriples, equalSubjects, equalPredicates, equalObjects,
subjectOf, predicateOf, objectOf, isEmpty,
rdfContainsNode, tripleContainsNode, removeDupes,
listSubjectsWithPredicate, listObjectsOfPredicate,
isIsomorphic, expandTriples, fromEither
) where
import Prelude hiding (pred)
import Data.List
import Data.RDF.Types
sortTriples :: Triples -> Triples
sortTriples = sort
subjectOf :: Triple -> Node
subjectOf (Triple s _ _) = s
predicateOf :: Triple -> Node
predicateOf (Triple _ p _) = p
objectOf :: Triple -> Node
objectOf (Triple _ _ o) = o
rdfContainsNode :: forall rdf. (RDF rdf) => rdf -> Node -> Bool
rdfContainsNode rdf node =
let ts = triplesOf rdf
xs = map (tripleContainsNode node) ts
in elem True xs
tripleContainsNode :: Node -> Triple -> Bool
tripleContainsNode node t =
subjectOf t == node || predicateOf t == node || objectOf t == node
equalSubjects :: Triple -> Triple -> Bool
equalSubjects (Triple s1 _ _) (Triple s2 _ _) = s1 == s2
equalPredicates :: Triple -> Triple -> Bool
equalPredicates (Triple _ p1 _) (Triple _ p2 _) = p1 == p2
equalObjects :: Triple -> Triple -> Bool
equalObjects (Triple _ _ o1) (Triple _ _ o2) = o1 == o2
isEmpty :: RDF rdf => rdf -> Bool
isEmpty rdf =
let ts = triplesOf rdf
in null ts
listSubjectsWithPredicate :: RDF rdf => rdf -> Predicate -> [Subject]
listSubjectsWithPredicate rdf pred =
listNodesWithPredicate rdf pred subjectOf
listObjectsOfPredicate :: RDF rdf => rdf -> Predicate -> [Object]
listObjectsOfPredicate rdf pred =
listNodesWithPredicate rdf pred objectOf
listNodesWithPredicate :: RDF rdf => rdf -> Predicate -> (Triple -> Node) -> [Node]
listNodesWithPredicate rdf pred f =
let ts = triplesOf rdf
xs = filter (\t -> predicateOf t == pred) ts
in map f xs
fromEither :: RDF rdf => Either ParseFailure rdf -> rdf
fromEither res =
case res of
(Left err) -> error (show err)
(Right rdf) -> rdf
removeDupes :: Triples -> Triples
removeDupes = map head . group . sort
isIsomorphic :: forall rdf1 rdf2. (RDF rdf1, RDF rdf2) => rdf1 -> rdf2 -> Bool
isIsomorphic g1 g2 = normalize g1 == normalize g2
where normalize :: forall rdf. (RDF rdf) => rdf -> Triples
normalize = sort . nub . expandTriples
expandTriples :: (RDF rdf) => rdf -> Triples
expandTriples rdf = expandTriples' [] (baseUrl rdf) (prefixMappings rdf) (triplesOf rdf)
expandTriples' :: Triples -> Maybe BaseUrl -> PrefixMappings -> Triples -> Triples
expandTriples' acc _ _ [] = acc
expandTriples' acc baseURL prefixMaps (t:rest) = expandTriples' (normalize baseURL prefixMaps t : acc) baseURL prefixMaps rest
where normalize baseURL' prefixMaps' = expandPrefixes prefixMaps' . expandBaseUrl baseURL'
expandBaseUrl (Just _) triple' = triple'
expandBaseUrl Nothing triple' = triple'
expandPrefixes _ triple' = triple'