-- | This module contains data structures for
--   taxonomy data

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DuplicateRecordFields #-}

module Biobase.Taxonomy.Types where
import Prelude
import qualified Data.ByteString.Char8 as B
import qualified Data.Aeson as A
import qualified Data.Vector as V
--import Data.Graph.Inductive
import Data.Graph.Inductive.Graph
import Data.Graph.Inductive.Tree
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
--import qualified Data.Text.Encoding

-- | SimpleTaxon only contains the most relevant fields of a taxonomy entry.
--   For all annotaded fields use the Taxon datatype and its associated functions
data SimpleTaxon = SimpleTaxon
  {
   -- node id in GenBank
   SimpleTaxon -> Int
simpleTaxId :: Int,
   SimpleTaxon -> Text
simpleScientificName :: TL.Text,
   -- parent node id in GenBank taxonomy database
   SimpleTaxon -> Int
simpleParentTaxId :: Int,
   -- rank of this node (superkingdom, kingdom, ...)
   SimpleTaxon -> Rank
simpleRank :: Rank
  }
  deriving (Int -> SimpleTaxon -> ShowS
[SimpleTaxon] -> ShowS
SimpleTaxon -> String
(Int -> SimpleTaxon -> ShowS)
-> (SimpleTaxon -> String)
-> ([SimpleTaxon] -> ShowS)
-> Show SimpleTaxon
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleTaxon] -> ShowS
$cshowList :: [SimpleTaxon] -> ShowS
show :: SimpleTaxon -> String
$cshow :: SimpleTaxon -> String
showsPrec :: Int -> SimpleTaxon -> ShowS
$cshowsPrec :: Int -> SimpleTaxon -> ShowS
Show, ReadPrec [SimpleTaxon]
ReadPrec SimpleTaxon
Int -> ReadS SimpleTaxon
ReadS [SimpleTaxon]
(Int -> ReadS SimpleTaxon)
-> ReadS [SimpleTaxon]
-> ReadPrec SimpleTaxon
-> ReadPrec [SimpleTaxon]
-> Read SimpleTaxon
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SimpleTaxon]
$creadListPrec :: ReadPrec [SimpleTaxon]
readPrec :: ReadPrec SimpleTaxon
$creadPrec :: ReadPrec SimpleTaxon
readList :: ReadS [SimpleTaxon]
$creadList :: ReadS [SimpleTaxon]
readsPrec :: Int -> ReadS SimpleTaxon
$creadsPrec :: Int -> ReadS SimpleTaxon
Read, SimpleTaxon -> SimpleTaxon -> Bool
(SimpleTaxon -> SimpleTaxon -> Bool)
-> (SimpleTaxon -> SimpleTaxon -> Bool) -> Eq SimpleTaxon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleTaxon -> SimpleTaxon -> Bool
$c/= :: SimpleTaxon -> SimpleTaxon -> Bool
== :: SimpleTaxon -> SimpleTaxon -> Bool
$c== :: SimpleTaxon -> SimpleTaxon -> Bool
Eq)

-- | Datastructure for tree comparisons
data CompareTaxon = CompareTaxon
  {
   CompareTaxon -> Text
compareScientificName :: TL.Text,
   CompareTaxon -> Rank
compareRank :: Rank,
   -- number indicating in which trees,
   CompareTaxon -> [Int]
inTree :: [Int]
  }
  deriving (Int -> CompareTaxon -> ShowS
[CompareTaxon] -> ShowS
CompareTaxon -> String
(Int -> CompareTaxon -> ShowS)
-> (CompareTaxon -> String)
-> ([CompareTaxon] -> ShowS)
-> Show CompareTaxon
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompareTaxon] -> ShowS
$cshowList :: [CompareTaxon] -> ShowS
show :: CompareTaxon -> String
$cshow :: CompareTaxon -> String
showsPrec :: Int -> CompareTaxon -> ShowS
$cshowsPrec :: Int -> CompareTaxon -> ShowS
Show, ReadPrec [CompareTaxon]
ReadPrec CompareTaxon
Int -> ReadS CompareTaxon
ReadS [CompareTaxon]
(Int -> ReadS CompareTaxon)
-> ReadS [CompareTaxon]
-> ReadPrec CompareTaxon
-> ReadPrec [CompareTaxon]
-> Read CompareTaxon
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompareTaxon]
$creadListPrec :: ReadPrec [CompareTaxon]
readPrec :: ReadPrec CompareTaxon
$creadPrec :: ReadPrec CompareTaxon
readList :: ReadS [CompareTaxon]
$creadList :: ReadS [CompareTaxon]
readsPrec :: Int -> ReadS CompareTaxon
$creadsPrec :: Int -> ReadS CompareTaxon
Read, CompareTaxon -> CompareTaxon -> Bool
(CompareTaxon -> CompareTaxon -> Bool)
-> (CompareTaxon -> CompareTaxon -> Bool) -> Eq CompareTaxon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompareTaxon -> CompareTaxon -> Bool
$c/= :: CompareTaxon -> CompareTaxon -> Bool
== :: CompareTaxon -> CompareTaxon -> Bool
$c== :: CompareTaxon -> CompareTaxon -> Bool
Eq)

-- | Data structure for Entrez taxonomy fetch result
data Taxon = Taxon
  {  Taxon -> Int
taxonTaxId :: Int
  ,  Taxon -> ByteString
taxonScientificName :: B.ByteString
  ,  Taxon -> Int
taxonParentTaxId :: Int
  ,  Taxon -> Rank
taxonRank :: Rank
  ,  Taxon -> ByteString
division :: B.ByteString
  ,  Taxon -> TaxGenCode
geneticCode :: TaxGenCode
  ,  Taxon -> TaxGenCode
mitoGeneticCode :: TaxGenCode
  ,  Taxon -> ByteString
lineage :: B.ByteString
  ,  Taxon -> [LineageTaxon]
lineageEx :: [LineageTaxon]
  ,  Taxon -> ByteString
createDate :: B.ByteString
  ,  Taxon -> ByteString
updateDate :: B.ByteString
  ,  Taxon -> ByteString
pubDate :: B.ByteString
  } deriving (Int -> Taxon -> ShowS
[Taxon] -> ShowS
Taxon -> String
(Int -> Taxon -> ShowS)
-> (Taxon -> String) -> ([Taxon] -> ShowS) -> Show Taxon
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Taxon] -> ShowS
$cshowList :: [Taxon] -> ShowS
show :: Taxon -> String
$cshow :: Taxon -> String
showsPrec :: Int -> Taxon -> ShowS
$cshowsPrec :: Int -> Taxon -> ShowS
Show, Taxon -> Taxon -> Bool
(Taxon -> Taxon -> Bool) -> (Taxon -> Taxon -> Bool) -> Eq Taxon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Taxon -> Taxon -> Bool
$c/= :: Taxon -> Taxon -> Bool
== :: Taxon -> Taxon -> Bool
$c== :: Taxon -> Taxon -> Bool
Eq)


data TaxonName = TaxonName
  {  TaxonName -> ByteString
classCDE :: B.ByteString
  ,  TaxonName -> ByteString
dispName :: B.ByteString
  } deriving (Int -> TaxonName -> ShowS
[TaxonName] -> ShowS
TaxonName -> String
(Int -> TaxonName -> ShowS)
-> (TaxonName -> String)
-> ([TaxonName] -> ShowS)
-> Show TaxonName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxonName] -> ShowS
$cshowList :: [TaxonName] -> ShowS
show :: TaxonName -> String
$cshow :: TaxonName -> String
showsPrec :: Int -> TaxonName -> ShowS
$cshowsPrec :: Int -> TaxonName -> ShowS
Show, TaxonName -> TaxonName -> Bool
(TaxonName -> TaxonName -> Bool)
-> (TaxonName -> TaxonName -> Bool) -> Eq TaxonName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxonName -> TaxonName -> Bool
$c/= :: TaxonName -> TaxonName -> Bool
== :: TaxonName -> TaxonName -> Bool
$c== :: TaxonName -> TaxonName -> Bool
Eq)

-- | Lineage Taxons denote all parent Taxonomy nodes of a node retrieved by Entrez fetch
data Lineage = Lineage
  {  Lineage -> Int
lineageStartTaxId :: Int
  ,  Lineage -> ByteString
lineageStartScienticName :: B.ByteString
  ,  Lineage -> Rank
lineageStartRank :: Rank
  ,  Lineage -> [LineageTaxon]
lineageTaxons :: [LineageTaxon]
  }
  deriving (Int -> Lineage -> ShowS
[Lineage] -> ShowS
Lineage -> String
(Int -> Lineage -> ShowS)
-> (Lineage -> String) -> ([Lineage] -> ShowS) -> Show Lineage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lineage] -> ShowS
$cshowList :: [Lineage] -> ShowS
show :: Lineage -> String
$cshow :: Lineage -> String
showsPrec :: Int -> Lineage -> ShowS
$cshowsPrec :: Int -> Lineage -> ShowS
Show, Lineage -> Lineage -> Bool
(Lineage -> Lineage -> Bool)
-> (Lineage -> Lineage -> Bool) -> Eq Lineage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lineage -> Lineage -> Bool
$c/= :: Lineage -> Lineage -> Bool
== :: Lineage -> Lineage -> Bool
$c== :: Lineage -> Lineage -> Bool
Eq)


-- | Lineage Taxons denote all parent Taxonomy nodes of a node retrieved by Entrez fetch
data LineageTaxon = LineageTaxon
  {  LineageTaxon -> Int
lineageTaxId :: Int
  ,  LineageTaxon -> ByteString
lineageScienticName :: B.ByteString
  ,  LineageTaxon -> Rank
lineageRank :: Rank}
  deriving (Int -> LineageTaxon -> ShowS
[LineageTaxon] -> ShowS
LineageTaxon -> String
(Int -> LineageTaxon -> ShowS)
-> (LineageTaxon -> String)
-> ([LineageTaxon] -> ShowS)
-> Show LineageTaxon
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LineageTaxon] -> ShowS
$cshowList :: [LineageTaxon] -> ShowS
show :: LineageTaxon -> String
$cshow :: LineageTaxon -> String
showsPrec :: Int -> LineageTaxon -> ShowS
$cshowsPrec :: Int -> LineageTaxon -> ShowS
Show, LineageTaxon -> LineageTaxon -> Bool
(LineageTaxon -> LineageTaxon -> Bool)
-> (LineageTaxon -> LineageTaxon -> Bool) -> Eq LineageTaxon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineageTaxon -> LineageTaxon -> Bool
$c/= :: LineageTaxon -> LineageTaxon -> Bool
== :: LineageTaxon -> LineageTaxon -> Bool
$c== :: LineageTaxon -> LineageTaxon -> Bool
Eq)

-- | NCBI Taxonomy database dump hierachichal data structure
-- as defined in ftp://ftp.ncbi.nih.gov/pub/taxonomy/taxdump_readme.txt
data NCBITaxDump = NCBITaxDump
  {
    NCBITaxDump -> [TaxCitation]
taxCitations :: [TaxCitation],
    NCBITaxDump -> [TaxDelNode]
taxDelNodes :: [TaxDelNode],
    NCBITaxDump -> [TaxDivision]
taxDivisions :: [TaxDivision],
    NCBITaxDump -> [TaxGenCode]
taxGenCodes :: [TaxGenCode],
    NCBITaxDump -> [TaxMergedNode]
taxMergedNodes :: [TaxMergedNode],
    NCBITaxDump -> [TaxName]
taxNames :: [TaxName],
    NCBITaxDump -> [TaxNode]
taxNodes :: [TaxNode]
  }
  deriving (Int -> NCBITaxDump -> ShowS
[NCBITaxDump] -> ShowS
NCBITaxDump -> String
(Int -> NCBITaxDump -> ShowS)
-> (NCBITaxDump -> String)
-> ([NCBITaxDump] -> ShowS)
-> Show NCBITaxDump
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NCBITaxDump] -> ShowS
$cshowList :: [NCBITaxDump] -> ShowS
show :: NCBITaxDump -> String
$cshow :: NCBITaxDump -> String
showsPrec :: Int -> NCBITaxDump -> ShowS
$cshowsPrec :: Int -> NCBITaxDump -> ShowS
Show, ReadPrec [NCBITaxDump]
ReadPrec NCBITaxDump
Int -> ReadS NCBITaxDump
ReadS [NCBITaxDump]
(Int -> ReadS NCBITaxDump)
-> ReadS [NCBITaxDump]
-> ReadPrec NCBITaxDump
-> ReadPrec [NCBITaxDump]
-> Read NCBITaxDump
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NCBITaxDump]
$creadListPrec :: ReadPrec [NCBITaxDump]
readPrec :: ReadPrec NCBITaxDump
$creadPrec :: ReadPrec NCBITaxDump
readList :: ReadS [NCBITaxDump]
$creadList :: ReadS [NCBITaxDump]
readsPrec :: Int -> ReadS NCBITaxDump
$creadsPrec :: Int -> ReadS NCBITaxDump
Read, NCBITaxDump -> NCBITaxDump -> Bool
(NCBITaxDump -> NCBITaxDump -> Bool)
-> (NCBITaxDump -> NCBITaxDump -> Bool) -> Eq NCBITaxDump
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NCBITaxDump -> NCBITaxDump -> Bool
$c/= :: NCBITaxDump -> NCBITaxDump -> Bool
== :: NCBITaxDump -> NCBITaxDump -> Bool
$c== :: NCBITaxDump -> NCBITaxDump -> Bool
Eq)

-- | Datastructure for entries of Taxonomy database dump citations file
data TaxCitation = TaxCitation
  {
   -- the unique id of citation
   TaxCitation -> Int
citId :: Int,
   -- citation key
   TaxCitation -> ByteString
citKey :: B.ByteString,
   -- unique id in PubMed database (0 if not in PubMed)
   TaxCitation -> Maybe Int
pubmedId :: Maybe Int,
   -- unique id in MedLine database (0 if not in MedLine)
   TaxCitation -> Maybe Int
medlineId :: Maybe Int,
   -- URL associated with citation
   TaxCitation -> ByteString
url :: B.ByteString,
   -- any text (usually article name and authors)
   -- The following characters are escaped in this text by a backslash:
   -- newline (appear as "\n"),
   -- tab character ("\t"),
   -- double quotes ('\"'),
   -- backslash character ("\\").
   TaxCitation -> ByteString
text :: B.ByteString,
   -- list of node ids separated by a single space
   TaxCitation -> [Int]
taxIdList :: [Int]
  }
  deriving (Int -> TaxCitation -> ShowS
[TaxCitation] -> ShowS
TaxCitation -> String
(Int -> TaxCitation -> ShowS)
-> (TaxCitation -> String)
-> ([TaxCitation] -> ShowS)
-> Show TaxCitation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxCitation] -> ShowS
$cshowList :: [TaxCitation] -> ShowS
show :: TaxCitation -> String
$cshow :: TaxCitation -> String
showsPrec :: Int -> TaxCitation -> ShowS
$cshowsPrec :: Int -> TaxCitation -> ShowS
Show, ReadPrec [TaxCitation]
ReadPrec TaxCitation
Int -> ReadS TaxCitation
ReadS [TaxCitation]
(Int -> ReadS TaxCitation)
-> ReadS [TaxCitation]
-> ReadPrec TaxCitation
-> ReadPrec [TaxCitation]
-> Read TaxCitation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxCitation]
$creadListPrec :: ReadPrec [TaxCitation]
readPrec :: ReadPrec TaxCitation
$creadPrec :: ReadPrec TaxCitation
readList :: ReadS [TaxCitation]
$creadList :: ReadS [TaxCitation]
readsPrec :: Int -> ReadS TaxCitation
$creadsPrec :: Int -> ReadS TaxCitation
Read, TaxCitation -> TaxCitation -> Bool
(TaxCitation -> TaxCitation -> Bool)
-> (TaxCitation -> TaxCitation -> Bool) -> Eq TaxCitation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxCitation -> TaxCitation -> Bool
$c/= :: TaxCitation -> TaxCitation -> Bool
== :: TaxCitation -> TaxCitation -> Bool
$c== :: TaxCitation -> TaxCitation -> Bool
Eq)

-- | Datastructure for entries of Taxonomy database dump deleted nodes file
data TaxDelNode = TaxDelNode
  {
   -- deleted node id
   TaxDelNode -> Int
delTaxId :: Int
  }
  deriving (Int -> TaxDelNode -> ShowS
[TaxDelNode] -> ShowS
TaxDelNode -> String
(Int -> TaxDelNode -> ShowS)
-> (TaxDelNode -> String)
-> ([TaxDelNode] -> ShowS)
-> Show TaxDelNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxDelNode] -> ShowS
$cshowList :: [TaxDelNode] -> ShowS
show :: TaxDelNode -> String
$cshow :: TaxDelNode -> String
showsPrec :: Int -> TaxDelNode -> ShowS
$cshowsPrec :: Int -> TaxDelNode -> ShowS
Show, ReadPrec [TaxDelNode]
ReadPrec TaxDelNode
Int -> ReadS TaxDelNode
ReadS [TaxDelNode]
(Int -> ReadS TaxDelNode)
-> ReadS [TaxDelNode]
-> ReadPrec TaxDelNode
-> ReadPrec [TaxDelNode]
-> Read TaxDelNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxDelNode]
$creadListPrec :: ReadPrec [TaxDelNode]
readPrec :: ReadPrec TaxDelNode
$creadPrec :: ReadPrec TaxDelNode
readList :: ReadS [TaxDelNode]
$creadList :: ReadS [TaxDelNode]
readsPrec :: Int -> ReadS TaxDelNode
$creadsPrec :: Int -> ReadS TaxDelNode
Read, TaxDelNode -> TaxDelNode -> Bool
(TaxDelNode -> TaxDelNode -> Bool)
-> (TaxDelNode -> TaxDelNode -> Bool) -> Eq TaxDelNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxDelNode -> TaxDelNode -> Bool
$c/= :: TaxDelNode -> TaxDelNode -> Bool
== :: TaxDelNode -> TaxDelNode -> Bool
$c== :: TaxDelNode -> TaxDelNode -> Bool
Eq)

-- | Datastructure for entries of Taxonomy database dump division file
data TaxDivision = TaxDivision
  {
   -- taxonomy database division id
   TaxDivision -> Int
divisionId :: Int,
   -- GenBank division code (three characters)
   TaxDivision -> ByteString
divisionCDE :: B.ByteString,
   -- e.g. BCT, PLN, VRT, MAM, PRI...
   TaxDivision -> ByteString
divisonName :: B.ByteString,
   TaxDivision -> ByteString
divisionComments :: B.ByteString
  }
  deriving (Int -> TaxDivision -> ShowS
[TaxDivision] -> ShowS
TaxDivision -> String
(Int -> TaxDivision -> ShowS)
-> (TaxDivision -> String)
-> ([TaxDivision] -> ShowS)
-> Show TaxDivision
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxDivision] -> ShowS
$cshowList :: [TaxDivision] -> ShowS
show :: TaxDivision -> String
$cshow :: TaxDivision -> String
showsPrec :: Int -> TaxDivision -> ShowS
$cshowsPrec :: Int -> TaxDivision -> ShowS
Show, ReadPrec [TaxDivision]
ReadPrec TaxDivision
Int -> ReadS TaxDivision
ReadS [TaxDivision]
(Int -> ReadS TaxDivision)
-> ReadS [TaxDivision]
-> ReadPrec TaxDivision
-> ReadPrec [TaxDivision]
-> Read TaxDivision
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxDivision]
$creadListPrec :: ReadPrec [TaxDivision]
readPrec :: ReadPrec TaxDivision
$creadPrec :: ReadPrec TaxDivision
readList :: ReadS [TaxDivision]
$creadList :: ReadS [TaxDivision]
readsPrec :: Int -> ReadS TaxDivision
$creadsPrec :: Int -> ReadS TaxDivision
Read, TaxDivision -> TaxDivision -> Bool
(TaxDivision -> TaxDivision -> Bool)
-> (TaxDivision -> TaxDivision -> Bool) -> Eq TaxDivision
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxDivision -> TaxDivision -> Bool
$c/= :: TaxDivision -> TaxDivision -> Bool
== :: TaxDivision -> TaxDivision -> Bool
$c== :: TaxDivision -> TaxDivision -> Bool
Eq)

-- | Datastructure for entries of Taxonomy database dump gencode file
data TaxGenCode = TaxGenCode
  {
   -- GenBank genetic code id
   TaxGenCode -> Int
geneticCodeId :: Int,
   -- genetic code name abbreviation
   TaxGenCode -> ByteString
abbreviation :: B.ByteString,
   -- genetic code name
   TaxGenCode -> ByteString
geneCodeName :: B.ByteString,
   -- translation table for this genetic code
   TaxGenCode -> ByteString
cde :: B.ByteString,
   -- start codons for this genetic code
   TaxGenCode -> ByteString
starts :: B.ByteString
  }
  deriving (Int -> TaxGenCode -> ShowS
[TaxGenCode] -> ShowS
TaxGenCode -> String
(Int -> TaxGenCode -> ShowS)
-> (TaxGenCode -> String)
-> ([TaxGenCode] -> ShowS)
-> Show TaxGenCode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxGenCode] -> ShowS
$cshowList :: [TaxGenCode] -> ShowS
show :: TaxGenCode -> String
$cshow :: TaxGenCode -> String
showsPrec :: Int -> TaxGenCode -> ShowS
$cshowsPrec :: Int -> TaxGenCode -> ShowS
Show, ReadPrec [TaxGenCode]
ReadPrec TaxGenCode
Int -> ReadS TaxGenCode
ReadS [TaxGenCode]
(Int -> ReadS TaxGenCode)
-> ReadS [TaxGenCode]
-> ReadPrec TaxGenCode
-> ReadPrec [TaxGenCode]
-> Read TaxGenCode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxGenCode]
$creadListPrec :: ReadPrec [TaxGenCode]
readPrec :: ReadPrec TaxGenCode
$creadPrec :: ReadPrec TaxGenCode
readList :: ReadS [TaxGenCode]
$creadList :: ReadS [TaxGenCode]
readsPrec :: Int -> ReadS TaxGenCode
$creadsPrec :: Int -> ReadS TaxGenCode
Read, TaxGenCode -> TaxGenCode -> Bool
(TaxGenCode -> TaxGenCode -> Bool)
-> (TaxGenCode -> TaxGenCode -> Bool) -> Eq TaxGenCode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxGenCode -> TaxGenCode -> Bool
$c/= :: TaxGenCode -> TaxGenCode -> Bool
== :: TaxGenCode -> TaxGenCode -> Bool
$c== :: TaxGenCode -> TaxGenCode -> Bool
Eq)

-- | Datastructure for entries of Taxonomy database dump mergednodes file
data TaxMergedNode = TaxMergedNode
  {
   -- id of nodes which has been merged
   TaxMergedNode -> Int
oldTaxId :: Int,
   -- id of nodes which is result of merging
   TaxMergedNode -> Int
newTaxId :: Int
  }
  deriving (Int -> TaxMergedNode -> ShowS
[TaxMergedNode] -> ShowS
TaxMergedNode -> String
(Int -> TaxMergedNode -> ShowS)
-> (TaxMergedNode -> String)
-> ([TaxMergedNode] -> ShowS)
-> Show TaxMergedNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxMergedNode] -> ShowS
$cshowList :: [TaxMergedNode] -> ShowS
show :: TaxMergedNode -> String
$cshow :: TaxMergedNode -> String
showsPrec :: Int -> TaxMergedNode -> ShowS
$cshowsPrec :: Int -> TaxMergedNode -> ShowS
Show, ReadPrec [TaxMergedNode]
ReadPrec TaxMergedNode
Int -> ReadS TaxMergedNode
ReadS [TaxMergedNode]
(Int -> ReadS TaxMergedNode)
-> ReadS [TaxMergedNode]
-> ReadPrec TaxMergedNode
-> ReadPrec [TaxMergedNode]
-> Read TaxMergedNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxMergedNode]
$creadListPrec :: ReadPrec [TaxMergedNode]
readPrec :: ReadPrec TaxMergedNode
$creadPrec :: ReadPrec TaxMergedNode
readList :: ReadS [TaxMergedNode]
$creadList :: ReadS [TaxMergedNode]
readsPrec :: Int -> ReadS TaxMergedNode
$creadsPrec :: Int -> ReadS TaxMergedNode
Read, TaxMergedNode -> TaxMergedNode -> Bool
(TaxMergedNode -> TaxMergedNode -> Bool)
-> (TaxMergedNode -> TaxMergedNode -> Bool) -> Eq TaxMergedNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxMergedNode -> TaxMergedNode -> Bool
$c/= :: TaxMergedNode -> TaxMergedNode -> Bool
== :: TaxMergedNode -> TaxMergedNode -> Bool
$c== :: TaxMergedNode -> TaxMergedNode -> Bool
Eq)

-- | Datastructure for entries of Taxonomy database dump names file
data TaxName = TaxName
  {
   -- the id of node associated with this name
   TaxName -> Int
nameTaxId :: Int,
   -- name itself
   TaxName -> Text
nameTxt :: TL.Text,
   -- the unique variant of this name if name not unique
   TaxName -> ByteString
uniqueName :: B.ByteString,
   -- (synonym, common name, ...)
   TaxName -> ByteString
nameClass :: B.ByteString
  }
  deriving (Int -> TaxName -> ShowS
[TaxName] -> ShowS
TaxName -> String
(Int -> TaxName -> ShowS)
-> (TaxName -> String) -> ([TaxName] -> ShowS) -> Show TaxName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxName] -> ShowS
$cshowList :: [TaxName] -> ShowS
show :: TaxName -> String
$cshow :: TaxName -> String
showsPrec :: Int -> TaxName -> ShowS
$cshowsPrec :: Int -> TaxName -> ShowS
Show, ReadPrec [TaxName]
ReadPrec TaxName
Int -> ReadS TaxName
ReadS [TaxName]
(Int -> ReadS TaxName)
-> ReadS [TaxName]
-> ReadPrec TaxName
-> ReadPrec [TaxName]
-> Read TaxName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxName]
$creadListPrec :: ReadPrec [TaxName]
readPrec :: ReadPrec TaxName
$creadPrec :: ReadPrec TaxName
readList :: ReadS [TaxName]
$creadList :: ReadS [TaxName]
readsPrec :: Int -> ReadS TaxName
$creadsPrec :: Int -> ReadS TaxName
Read, TaxName -> TaxName -> Bool
(TaxName -> TaxName -> Bool)
-> (TaxName -> TaxName -> Bool) -> Eq TaxName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxName -> TaxName -> Bool
$c/= :: TaxName -> TaxName -> Bool
== :: TaxName -> TaxName -> Bool
$c== :: TaxName -> TaxName -> Bool
Eq)

-- | Taxonomic ranks: NCBI uses the uncommon Speciessubgroup
data Rank = Norank | Form | Variety | Infraspecies | Subspecies | Speciessubgroup | Species | Speciesgroup | Superspecies | Series | Section | Subgenus | Genus | Subtribe | Tribe | Supertribe | Subfamily | Family | Superfamily | Parvorder | Infraorder | Suborder | Order | Superorder | Magnorder | Cohort | Legion | Parvclass | Infraclass | Subclass | Class | Superclass | Microphylum | Infraphylum | Subphylum | Phylum | Superphylum | Infrakingdom | Subkingdom | Kingdom | Superkingdom | Domain deriving (Rank -> Rank -> Bool
(Rank -> Rank -> Bool) -> (Rank -> Rank -> Bool) -> Eq Rank
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Rank -> Rank -> Bool
$c/= :: Rank -> Rank -> Bool
== :: Rank -> Rank -> Bool
$c== :: Rank -> Rank -> Bool
Eq, Eq Rank
Eq Rank
-> (Rank -> Rank -> Ordering)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Rank)
-> (Rank -> Rank -> Rank)
-> Ord Rank
Rank -> Rank -> Bool
Rank -> Rank -> Ordering
Rank -> Rank -> Rank
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Rank -> Rank -> Rank
$cmin :: Rank -> Rank -> Rank
max :: Rank -> Rank -> Rank
$cmax :: Rank -> Rank -> Rank
>= :: Rank -> Rank -> Bool
$c>= :: Rank -> Rank -> Bool
> :: Rank -> Rank -> Bool
$c> :: Rank -> Rank -> Bool
<= :: Rank -> Rank -> Bool
$c<= :: Rank -> Rank -> Bool
< :: Rank -> Rank -> Bool
$c< :: Rank -> Rank -> Bool
compare :: Rank -> Rank -> Ordering
$ccompare :: Rank -> Rank -> Ordering
$cp1Ord :: Eq Rank
Ord, Int -> Rank -> ShowS
[Rank] -> ShowS
Rank -> String
(Int -> Rank -> ShowS)
-> (Rank -> String) -> ([Rank] -> ShowS) -> Show Rank
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Rank] -> ShowS
$cshowList :: [Rank] -> ShowS
show :: Rank -> String
$cshow :: Rank -> String
showsPrec :: Int -> Rank -> ShowS
$cshowsPrec :: Int -> Rank -> ShowS
Show, Rank
Rank -> Rank -> Bounded Rank
forall a. a -> a -> Bounded a
maxBound :: Rank
$cmaxBound :: Rank
minBound :: Rank
$cminBound :: Rank
Bounded, Int -> Rank
Rank -> Int
Rank -> [Rank]
Rank -> Rank
Rank -> Rank -> [Rank]
Rank -> Rank -> Rank -> [Rank]
(Rank -> Rank)
-> (Rank -> Rank)
-> (Int -> Rank)
-> (Rank -> Int)
-> (Rank -> [Rank])
-> (Rank -> Rank -> [Rank])
-> (Rank -> Rank -> [Rank])
-> (Rank -> Rank -> Rank -> [Rank])
-> Enum Rank
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Rank -> Rank -> Rank -> [Rank]
$cenumFromThenTo :: Rank -> Rank -> Rank -> [Rank]
enumFromTo :: Rank -> Rank -> [Rank]
$cenumFromTo :: Rank -> Rank -> [Rank]
enumFromThen :: Rank -> Rank -> [Rank]
$cenumFromThen :: Rank -> Rank -> [Rank]
enumFrom :: Rank -> [Rank]
$cenumFrom :: Rank -> [Rank]
fromEnum :: Rank -> Int
$cfromEnum :: Rank -> Int
toEnum :: Int -> Rank
$ctoEnum :: Int -> Rank
pred :: Rank -> Rank
$cpred :: Rank -> Rank
succ :: Rank -> Rank
$csucc :: Rank -> Rank
Enum)

readsRank :: String -> [(Rank, String)]
instance Read Rank where
  readsPrec :: Int -> ReadS Rank
readsPrec Int
_ = ReadS Rank
readsRank

readsRank :: ReadS Rank
readsRank String
input -- = [(Domain x)| x <- reads input ]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"domain" = [(Rank
Domain,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"superkingdom" = [(Rank
Superkingdom,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"kingdom" = [(Rank
Kingdom,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subkingdom"  = [(Rank
Subkingdom,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"infrakingdom" = [(Rank
Infrakingdom,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"superphylum" = [(Rank
Superphylum,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"phylum" = [(Rank
Phylum,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subphylum" = [(Rank
Subphylum,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"infraphylum" = [(Rank
Infraphylum,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"microphylum" = [(Rank
Microphylum,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"superclass" = [(Rank
Superclass,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"class" = [(Rank
Class,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subclass" = [(Rank
Subclass,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"infraclass" = [(Rank
Infraclass,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"parvclass " = [(Rank
Parvclass ,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"legion" = [(Rank
Legion,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"cohort" = [(Rank
Cohort,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"magnorder " = [(Rank
Magnorder ,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"superorder" = [(Rank
Superorder,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"order" = [(Rank
Order,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"suborder" = [(Rank
Suborder,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"infraorder" = [(Rank
Infraorder,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"parvorder" = [(Rank
Parvorder,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"superfamily" = [(Rank
Superfamily,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"family" = [(Rank
Family,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subfamily" = [(Rank
Subfamily,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"supertribe" = [(Rank
Supertribe,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"tribe" = [(Rank
Tribe,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subtribe" = [(Rank
Subtribe,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"genus" = [(Rank
Genus,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subgenus" = [(Rank
Subgenus,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"section" = [(Rank
Section,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"series" = [(Rank
Series,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"superspecies" = [(Rank
Superspecies,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"species group" = [(Rank
Speciesgroup,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"species" = [(Rank
Species,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"species subgroup" = [(Rank
Speciessubgroup,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"subspecies" = [(Rank
Subspecies,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"infraspecies" = [(Rank
Infraspecies,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"varietas" = [(Rank
Variety,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"forma" = [(Rank
Form,String
"")]
   | String
input String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"no rank" = [(Rank
Norank,String
"")]
   | Bool
otherwise = [(Rank
Norank,String
"")]

-- | Datastructure for entries of Taxonomy database dump nodes file
data TaxNode = TaxNode
  {
   -- node id in GenBank
   TaxNode -> Int
taxId :: Int,
   -- parent node id in GenBank taxonomy database
   TaxNode -> Int
parentTaxId :: Int,
   -- rank of this node (superkingdom, kingdom, ...)
   TaxNode -> Rank
rank :: Rank,
   -- locus-name prefix; not unique
   TaxNode -> ByteString
emblCode :: B.ByteString,
   -- see division.dmp file
   TaxNode -> Int
nodeDivisionId :: Int,
   -- 1 if node inherits division from parent
   TaxNode -> Bool
inheritedDivFlag :: Bool,
   -- see gencode.dmp file
   TaxNode -> Int
nodeGeneticCodeId :: Int,
   -- 1 if node inherits genetic code from parent
   TaxNode -> Bool
inheritedGCFlag :: Bool,
   -- see gencode.dmp file
   TaxNode -> Int
mitochondrialGeneticCodeId :: Int,
   -- 1 if node inherits mitochondrial gencode from parent
   TaxNode -> Bool
inheritedMGCFlag :: Bool,
   -- 1 if name is suppressed in GenBank entry lineage
   TaxNode -> Bool
genBankHiddenFlag :: Bool,
   -- 1 if this subtree has no sequence data yet
   TaxNode -> Bool
hiddenSubtreeRootFlag :: Bool,
   -- free-text comments and citations
   TaxNode -> ByteString
nodeComments :: B.ByteString
  }
  deriving (Int -> TaxNode -> ShowS
[TaxNode] -> ShowS
TaxNode -> String
(Int -> TaxNode -> ShowS)
-> (TaxNode -> String) -> ([TaxNode] -> ShowS) -> Show TaxNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaxNode] -> ShowS
$cshowList :: [TaxNode] -> ShowS
show :: TaxNode -> String
$cshow :: TaxNode -> String
showsPrec :: Int -> TaxNode -> ShowS
$cshowsPrec :: Int -> TaxNode -> ShowS
Show, ReadPrec [TaxNode]
ReadPrec TaxNode
Int -> ReadS TaxNode
ReadS [TaxNode]
(Int -> ReadS TaxNode)
-> ReadS [TaxNode]
-> ReadPrec TaxNode
-> ReadPrec [TaxNode]
-> Read TaxNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaxNode]
$creadListPrec :: ReadPrec [TaxNode]
readPrec :: ReadPrec TaxNode
$creadPrec :: ReadPrec TaxNode
readList :: ReadS [TaxNode]
$creadList :: ReadS [TaxNode]
readsPrec :: Int -> ReadS TaxNode
$creadsPrec :: Int -> ReadS TaxNode
Read, TaxNode -> TaxNode -> Bool
(TaxNode -> TaxNode -> Bool)
-> (TaxNode -> TaxNode -> Bool) -> Eq TaxNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaxNode -> TaxNode -> Bool
$c/= :: TaxNode -> TaxNode -> Bool
== :: TaxNode -> TaxNode -> Bool
$c== :: TaxNode -> TaxNode -> Bool
Eq)

-- | Simple Gene2Accession table
data SimpleGene2Accession = SimpleGene2Accession
  { SimpleGene2Accession -> Int
simpleTaxIdEntry :: Int,
    SimpleGene2Accession -> ByteString
simpleGenomicNucleotideAccessionVersion :: B.ByteString
  } deriving (Int -> SimpleGene2Accession -> ShowS
[SimpleGene2Accession] -> ShowS
SimpleGene2Accession -> String
(Int -> SimpleGene2Accession -> ShowS)
-> (SimpleGene2Accession -> String)
-> ([SimpleGene2Accession] -> ShowS)
-> Show SimpleGene2Accession
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleGene2Accession] -> ShowS
$cshowList :: [SimpleGene2Accession] -> ShowS
show :: SimpleGene2Accession -> String
$cshow :: SimpleGene2Accession -> String
showsPrec :: Int -> SimpleGene2Accession -> ShowS
$cshowsPrec :: Int -> SimpleGene2Accession -> ShowS
Show, SimpleGene2Accession -> SimpleGene2Accession -> Bool
(SimpleGene2Accession -> SimpleGene2Accession -> Bool)
-> (SimpleGene2Accession -> SimpleGene2Accession -> Bool)
-> Eq SimpleGene2Accession
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleGene2Accession -> SimpleGene2Accession -> Bool
$c/= :: SimpleGene2Accession -> SimpleGene2Accession -> Bool
== :: SimpleGene2Accession -> SimpleGene2Accession -> Bool
$c== :: SimpleGene2Accession -> SimpleGene2Accession -> Bool
Eq, ReadPrec [SimpleGene2Accession]
ReadPrec SimpleGene2Accession
Int -> ReadS SimpleGene2Accession
ReadS [SimpleGene2Accession]
(Int -> ReadS SimpleGene2Accession)
-> ReadS [SimpleGene2Accession]
-> ReadPrec SimpleGene2Accession
-> ReadPrec [SimpleGene2Accession]
-> Read SimpleGene2Accession
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SimpleGene2Accession]
$creadListPrec :: ReadPrec [SimpleGene2Accession]
readPrec :: ReadPrec SimpleGene2Accession
$creadPrec :: ReadPrec SimpleGene2Accession
readList :: ReadS [SimpleGene2Accession]
$creadList :: ReadS [SimpleGene2Accession]
readsPrec :: Int -> ReadS SimpleGene2Accession
$creadsPrec :: Int -> ReadS SimpleGene2Accession
Read)

-- | Datastructure for Gene2Accession table
data Gene2Accession = Gene2Accession
  { Gene2Accession -> Int
taxIdEntry :: Int,
    Gene2Accession -> Int
geneID :: Int,
    Gene2Accession -> ByteString
status :: B.ByteString,
    Gene2Accession -> ByteString
rnaNucleotideAccessionVersion :: B.ByteString,
    Gene2Accession -> ByteString
rnaNucleotideGi :: B.ByteString,
    Gene2Accession -> ByteString
proteinAccessionVersion :: B.ByteString,
    Gene2Accession -> ByteString
proteinGi :: B.ByteString,
    Gene2Accession -> ByteString
genomicNucleotideAccessionVersion :: B.ByteString,
    Gene2Accession -> ByteString
genomicNucleotideGi :: B.ByteString,
    Gene2Accession -> ByteString
startPositionOnTheGenomicAccession :: B.ByteString,
    Gene2Accession -> ByteString
endPositionOnTheGenomicAccession ::  B.ByteString,
    Gene2Accession -> ByteString
orientation :: B.ByteString,
    Gene2Accession -> ByteString
assembly :: B.ByteString,
    Gene2Accession -> ByteString
maturePeptideAccessionVersion :: B.ByteString,
    Gene2Accession -> ByteString
maturePeptideGi :: B.ByteString
  } deriving (Int -> Gene2Accession -> ShowS
[Gene2Accession] -> ShowS
Gene2Accession -> String
(Int -> Gene2Accession -> ShowS)
-> (Gene2Accession -> String)
-> ([Gene2Accession] -> ShowS)
-> Show Gene2Accession
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Gene2Accession] -> ShowS
$cshowList :: [Gene2Accession] -> ShowS
show :: Gene2Accession -> String
$cshow :: Gene2Accession -> String
showsPrec :: Int -> Gene2Accession -> ShowS
$cshowsPrec :: Int -> Gene2Accession -> ShowS
Show, Gene2Accession -> Gene2Accession -> Bool
(Gene2Accession -> Gene2Accession -> Bool)
-> (Gene2Accession -> Gene2Accession -> Bool) -> Eq Gene2Accession
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gene2Accession -> Gene2Accession -> Bool
$c/= :: Gene2Accession -> Gene2Accession -> Bool
== :: Gene2Accession -> Gene2Accession -> Bool
$c== :: Gene2Accession -> Gene2Accession -> Bool
Eq, ReadPrec [Gene2Accession]
ReadPrec Gene2Accession
Int -> ReadS Gene2Accession
ReadS [Gene2Accession]
(Int -> ReadS Gene2Accession)
-> ReadS [Gene2Accession]
-> ReadPrec Gene2Accession
-> ReadPrec [Gene2Accession]
-> Read Gene2Accession
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Gene2Accession]
$creadListPrec :: ReadPrec [Gene2Accession]
readPrec :: ReadPrec Gene2Accession
$creadPrec :: ReadPrec Gene2Accession
readList :: ReadS [Gene2Accession]
$creadList :: ReadS [Gene2Accession]
readsPrec :: Int -> ReadS Gene2Accession
$creadsPrec :: Int -> ReadS Gene2Accession
Read)

instance A.ToJSON (Gr SimpleTaxon Double) where
  toJSON :: Gr SimpleTaxon Double -> Value
toJSON Gr SimpleTaxon Double
inputGraph = Gr SimpleTaxon Double -> Int -> Value
simpleTaxonJSONValue Gr SimpleTaxon Double
inputGraph Int
1

simpleTaxonJSONValue :: Gr SimpleTaxon Double -> Node -> A.Value
simpleTaxonJSONValue :: Gr SimpleTaxon Double -> Int -> Value
simpleTaxonJSONValue Gr SimpleTaxon Double
inputGraph Int
node = Value
jsonValue
  where jsonValue :: Value
jsonValue = [Pair] -> Value
A.object [Pair
currentScientificName,String -> Text
T.pack String
"children" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..= Value
children]
        childNodes :: [Int]
childNodes = Gr SimpleTaxon Double -> Int -> [Int]
forall (gr :: * -> * -> *) a b. Graph gr => gr a b -> Int -> [Int]
suc Gr SimpleTaxon Double
inputGraph Int
node
        currentLabel :: Maybe SimpleTaxon
currentLabel = Gr SimpleTaxon Double -> Int -> Maybe SimpleTaxon
forall (gr :: * -> * -> *) a b.
Graph gr =>
gr a b -> Int -> Maybe a
lab Gr SimpleTaxon Double
inputGraph Int
node
        currentScientificName :: Pair
currentScientificName = String -> Text
T.pack String
"name" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..= Text -> (SimpleTaxon -> Text) -> Maybe SimpleTaxon -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Text
T.pack String
"notFound") (Text -> Text
TL.toStrict  (Text -> Text) -> (SimpleTaxon -> Text) -> SimpleTaxon -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SimpleTaxon -> Text
simpleScientificName) Maybe SimpleTaxon
currentLabel
        children :: Value
children = Array -> Value
A.Array ([Value] -> Array
forall a. [a] -> Vector a
V.fromList ((Int -> Value) -> [Int] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map (Gr SimpleTaxon Double -> Int -> Value
simpleTaxonJSONValue Gr SimpleTaxon Double
inputGraph) [Int]
childNodes))
        --jsonValue = A.object [currentScientificName,currentId,currentRank,(T.pack "children") A..= children]
        --currentId = (T.pack "id") A..= (maybe (T.pack "notFound") (\a -> T.pack (show (simpleTaxId a))) currentLabel)
        --currentRank = (T.pack "rank") A..= (maybe (T.pack "notFound") (\a -> T.pack (show (simpleRank a))) currentLabel)