module JVM.Data.Abstract.Name where

import Data.Data
import Data.String (IsString (fromString))
import Data.Text (Text)
import Data.Text qualified as T
import JVM.Data.Pretty

{- | A JVM package name
This is defined as a potentially empty list of identifiers, which would be separated by dots in the source code
-}
newtype PackageName = PackageName [Text] deriving (Int -> PackageName -> ShowS
[PackageName] -> ShowS
PackageName -> String
(Int -> PackageName -> ShowS)
-> (PackageName -> String)
-> ([PackageName] -> ShowS)
-> Show PackageName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PackageName -> ShowS
showsPrec :: Int -> PackageName -> ShowS
$cshow :: PackageName -> String
show :: PackageName -> String
$cshowList :: [PackageName] -> ShowS
showList :: [PackageName] -> ShowS
Show, PackageName -> PackageName -> Bool
(PackageName -> PackageName -> Bool)
-> (PackageName -> PackageName -> Bool) -> Eq PackageName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackageName -> PackageName -> Bool
== :: PackageName -> PackageName -> Bool
$c/= :: PackageName -> PackageName -> Bool
/= :: PackageName -> PackageName -> Bool
Eq, Eq PackageName
Eq PackageName =>
(PackageName -> PackageName -> Ordering)
-> (PackageName -> PackageName -> Bool)
-> (PackageName -> PackageName -> Bool)
-> (PackageName -> PackageName -> Bool)
-> (PackageName -> PackageName -> Bool)
-> (PackageName -> PackageName -> PackageName)
-> (PackageName -> PackageName -> PackageName)
-> Ord PackageName
PackageName -> PackageName -> Bool
PackageName -> PackageName -> Ordering
PackageName -> PackageName -> PackageName
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
$ccompare :: PackageName -> PackageName -> Ordering
compare :: PackageName -> PackageName -> Ordering
$c< :: PackageName -> PackageName -> Bool
< :: PackageName -> PackageName -> Bool
$c<= :: PackageName -> PackageName -> Bool
<= :: PackageName -> PackageName -> Bool
$c> :: PackageName -> PackageName -> Bool
> :: PackageName -> PackageName -> Bool
$c>= :: PackageName -> PackageName -> Bool
>= :: PackageName -> PackageName -> Bool
$cmax :: PackageName -> PackageName -> PackageName
max :: PackageName -> PackageName -> PackageName
$cmin :: PackageName -> PackageName -> PackageName
min :: PackageName -> PackageName -> PackageName
Ord, Typeable PackageName
Typeable PackageName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PackageName -> c PackageName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PackageName)
-> (PackageName -> Constr)
-> (PackageName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PackageName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PackageName))
-> ((forall b. Data b => b -> b) -> PackageName -> PackageName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PackageName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PackageName -> r)
-> (forall u. (forall d. Data d => d -> u) -> PackageName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PackageName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PackageName -> m PackageName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PackageName -> m PackageName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PackageName -> m PackageName)
-> Data PackageName
PackageName -> Constr
PackageName -> DataType
(forall b. Data b => b -> b) -> PackageName -> PackageName
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PackageName -> u
forall u. (forall d. Data d => d -> u) -> PackageName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackageName -> c PackageName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackageName -> c PackageName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackageName -> c PackageName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageName
$ctoConstr :: PackageName -> Constr
toConstr :: PackageName -> Constr
$cdataTypeOf :: PackageName -> DataType
dataTypeOf :: PackageName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageName)
$cgmapT :: (forall b. Data b => b -> b) -> PackageName -> PackageName
gmapT :: (forall b. Data b => b -> b) -> PackageName -> PackageName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PackageName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PackageName -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PackageName -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PackageName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageName -> m PackageName
Data)

{- | Parse a 'PackageName' from a 'Text'

>>> parsePackageName "java.lang"
PackageName ["java","lang"]

>>> parsePackageName ""
PackageName []
-}
parsePackageName :: Text -> PackageName
parsePackageName :: Text -> PackageName
parsePackageName Text
t = case HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
T.splitOn Text
"." Text
t of
    [Text
""] -> [Text] -> PackageName
PackageName []
    [Text]
xs -> [Text] -> PackageName
PackageName [Text]
xs

-- | A JVM class name
newtype ClassName = ClassName Text deriving (Int -> ClassName -> ShowS
[ClassName] -> ShowS
ClassName -> String
(Int -> ClassName -> ShowS)
-> (ClassName -> String)
-> ([ClassName] -> ShowS)
-> Show ClassName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClassName -> ShowS
showsPrec :: Int -> ClassName -> ShowS
$cshow :: ClassName -> String
show :: ClassName -> String
$cshowList :: [ClassName] -> ShowS
showList :: [ClassName] -> ShowS
Show, ClassName -> ClassName -> Bool
(ClassName -> ClassName -> Bool)
-> (ClassName -> ClassName -> Bool) -> Eq ClassName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassName -> ClassName -> Bool
== :: ClassName -> ClassName -> Bool
$c/= :: ClassName -> ClassName -> Bool
/= :: ClassName -> ClassName -> Bool
Eq, Eq ClassName
Eq ClassName =>
(ClassName -> ClassName -> Ordering)
-> (ClassName -> ClassName -> Bool)
-> (ClassName -> ClassName -> Bool)
-> (ClassName -> ClassName -> Bool)
-> (ClassName -> ClassName -> Bool)
-> (ClassName -> ClassName -> ClassName)
-> (ClassName -> ClassName -> ClassName)
-> Ord ClassName
ClassName -> ClassName -> Bool
ClassName -> ClassName -> Ordering
ClassName -> ClassName -> ClassName
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
$ccompare :: ClassName -> ClassName -> Ordering
compare :: ClassName -> ClassName -> Ordering
$c< :: ClassName -> ClassName -> Bool
< :: ClassName -> ClassName -> Bool
$c<= :: ClassName -> ClassName -> Bool
<= :: ClassName -> ClassName -> Bool
$c> :: ClassName -> ClassName -> Bool
> :: ClassName -> ClassName -> Bool
$c>= :: ClassName -> ClassName -> Bool
>= :: ClassName -> ClassName -> Bool
$cmax :: ClassName -> ClassName -> ClassName
max :: ClassName -> ClassName -> ClassName
$cmin :: ClassName -> ClassName -> ClassName
min :: ClassName -> ClassName -> ClassName
Ord, Typeable ClassName
Typeable ClassName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ClassName -> c ClassName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ClassName)
-> (ClassName -> Constr)
-> (ClassName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ClassName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassName))
-> ((forall b. Data b => b -> b) -> ClassName -> ClassName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassName -> r)
-> (forall u. (forall d. Data d => d -> u) -> ClassName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ClassName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassName -> m ClassName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassName -> m ClassName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassName -> m ClassName)
-> Data ClassName
ClassName -> Constr
ClassName -> DataType
(forall b. Data b => b -> b) -> ClassName -> ClassName
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ClassName -> u
forall u. (forall d. Data d => d -> u) -> ClassName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassName -> c ClassName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassName -> c ClassName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassName -> c ClassName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassName
$ctoConstr :: ClassName -> Constr
toConstr :: ClassName -> Constr
$cdataTypeOf :: ClassName -> DataType
dataTypeOf :: ClassName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassName)
$cgmapT :: (forall b. Data b => b -> b) -> ClassName -> ClassName
gmapT :: (forall b. Data b => b -> b) -> ClassName -> ClassName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClassName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassName -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassName -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassName -> m ClassName
Data)

-- | Parse a 'ClassName' from a 'Text'
parseClassName :: Text -> ClassName
parseClassName :: Text -> ClassName
parseClassName = Text -> ClassName
ClassName

data QualifiedClassName = QualifiedClassName PackageName ClassName deriving (Int -> QualifiedClassName -> ShowS
[QualifiedClassName] -> ShowS
QualifiedClassName -> String
(Int -> QualifiedClassName -> ShowS)
-> (QualifiedClassName -> String)
-> ([QualifiedClassName] -> ShowS)
-> Show QualifiedClassName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualifiedClassName -> ShowS
showsPrec :: Int -> QualifiedClassName -> ShowS
$cshow :: QualifiedClassName -> String
show :: QualifiedClassName -> String
$cshowList :: [QualifiedClassName] -> ShowS
showList :: [QualifiedClassName] -> ShowS
Show, QualifiedClassName -> QualifiedClassName -> Bool
(QualifiedClassName -> QualifiedClassName -> Bool)
-> (QualifiedClassName -> QualifiedClassName -> Bool)
-> Eq QualifiedClassName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedClassName -> QualifiedClassName -> Bool
== :: QualifiedClassName -> QualifiedClassName -> Bool
$c/= :: QualifiedClassName -> QualifiedClassName -> Bool
/= :: QualifiedClassName -> QualifiedClassName -> Bool
Eq, Eq QualifiedClassName
Eq QualifiedClassName =>
(QualifiedClassName -> QualifiedClassName -> Ordering)
-> (QualifiedClassName -> QualifiedClassName -> Bool)
-> (QualifiedClassName -> QualifiedClassName -> Bool)
-> (QualifiedClassName -> QualifiedClassName -> Bool)
-> (QualifiedClassName -> QualifiedClassName -> Bool)
-> (QualifiedClassName -> QualifiedClassName -> QualifiedClassName)
-> (QualifiedClassName -> QualifiedClassName -> QualifiedClassName)
-> Ord QualifiedClassName
QualifiedClassName -> QualifiedClassName -> Bool
QualifiedClassName -> QualifiedClassName -> Ordering
QualifiedClassName -> QualifiedClassName -> QualifiedClassName
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
$ccompare :: QualifiedClassName -> QualifiedClassName -> Ordering
compare :: QualifiedClassName -> QualifiedClassName -> Ordering
$c< :: QualifiedClassName -> QualifiedClassName -> Bool
< :: QualifiedClassName -> QualifiedClassName -> Bool
$c<= :: QualifiedClassName -> QualifiedClassName -> Bool
<= :: QualifiedClassName -> QualifiedClassName -> Bool
$c> :: QualifiedClassName -> QualifiedClassName -> Bool
> :: QualifiedClassName -> QualifiedClassName -> Bool
$c>= :: QualifiedClassName -> QualifiedClassName -> Bool
>= :: QualifiedClassName -> QualifiedClassName -> Bool
$cmax :: QualifiedClassName -> QualifiedClassName -> QualifiedClassName
max :: QualifiedClassName -> QualifiedClassName -> QualifiedClassName
$cmin :: QualifiedClassName -> QualifiedClassName -> QualifiedClassName
min :: QualifiedClassName -> QualifiedClassName -> QualifiedClassName
Ord, Typeable QualifiedClassName
Typeable QualifiedClassName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> QualifiedClassName
 -> c QualifiedClassName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QualifiedClassName)
-> (QualifiedClassName -> Constr)
-> (QualifiedClassName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QualifiedClassName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c QualifiedClassName))
-> ((forall b. Data b => b -> b)
    -> QualifiedClassName -> QualifiedClassName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> QualifiedClassName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> QualifiedClassName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> QualifiedClassName -> m QualifiedClassName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualifiedClassName -> m QualifiedClassName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualifiedClassName -> m QualifiedClassName)
-> Data QualifiedClassName
QualifiedClassName -> Constr
QualifiedClassName -> DataType
(forall b. Data b => b -> b)
-> QualifiedClassName -> QualifiedClassName
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> QualifiedClassName -> u
forall u. (forall d. Data d => d -> u) -> QualifiedClassName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QualifiedClassName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> QualifiedClassName
-> c QualifiedClassName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QualifiedClassName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c QualifiedClassName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> QualifiedClassName
-> c QualifiedClassName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> QualifiedClassName
-> c QualifiedClassName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QualifiedClassName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QualifiedClassName
$ctoConstr :: QualifiedClassName -> Constr
toConstr :: QualifiedClassName -> Constr
$cdataTypeOf :: QualifiedClassName -> DataType
dataTypeOf :: QualifiedClassName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QualifiedClassName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QualifiedClassName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c QualifiedClassName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c QualifiedClassName)
$cgmapT :: (forall b. Data b => b -> b)
-> QualifiedClassName -> QualifiedClassName
gmapT :: (forall b. Data b => b -> b)
-> QualifiedClassName -> QualifiedClassName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualifiedClassName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> QualifiedClassName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QualifiedClassName -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> QualifiedClassName -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> QualifiedClassName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> QualifiedClassName -> m QualifiedClassName
Data)

instance Pretty QualifiedClassName where
    pretty :: forall ann. QualifiedClassName -> Doc ann
pretty (QualifiedClassName (PackageName []) (ClassName Text
c)) = Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
c
    pretty (QualifiedClassName (PackageName [Text]
p) (ClassName Text
c)) = Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty (Text -> Doc ann) -> Text -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
T.intercalate Text
"." ([Text]
p [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<> [Text
c])

instance IsString QualifiedClassName where
    fromString :: String -> QualifiedClassName
fromString = Text -> QualifiedClassName
parseQualifiedClassName (Text -> QualifiedClassName)
-> (String -> Text) -> String -> QualifiedClassName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

{- | Parse a 'QualifiedClassName' from a 'Text'

>>> parseQualifiedClassName "java.lang.Object"
QualifiedClassName (PackageName ["java","lang"]) (ClassName "Object")

>>> parseQualifiedClassName "Object"
QualifiedClassName (PackageName []) (ClassName "Object")

This function is lenient and will accept invalid class names:
>>> parseQualifiedClassName "123invalid"
QualifiedClassName (PackageName []) (ClassName "123invalid")
-}
parseQualifiedClassName :: Text -> QualifiedClassName
parseQualifiedClassName :: Text -> QualifiedClassName
parseQualifiedClassName Text
t = case HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
T.splitOn Text
"." Text
t of
    [Text
c] -> PackageName -> ClassName -> QualifiedClassName
QualifiedClassName ([Text] -> PackageName
PackageName []) (Text -> ClassName
ClassName Text
c)
    [Text]
xs -> PackageName -> ClassName -> QualifiedClassName
QualifiedClassName ([Text] -> PackageName
PackageName ([Text] -> PackageName) -> [Text] -> PackageName
forall a b. (a -> b) -> a -> b
$ [Text] -> [Text]
forall a. HasCallStack => [a] -> [a]
init [Text]
xs) (Text -> ClassName
ClassName (Text -> ClassName) -> Text -> ClassName
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
forall a. HasCallStack => [a] -> a
last [Text]
xs)

{- | Convert a 'QualifiedClassName' to a 'Text' that can be used as an internal JVM name

>>> toInternalName (QualifiedClassName (PackageName ["java","lang"]) (ClassName "Object"))
"java/lang/Object"
-}
toInternalName :: QualifiedClassName -> Text
toInternalName :: QualifiedClassName -> Text
toInternalName (QualifiedClassName (PackageName []) (ClassName Text
c)) = Text
c
toInternalName (QualifiedClassName (PackageName [Text]
p) (ClassName Text
c)) = Text -> [Text] -> Text
T.intercalate Text
"/" ([Text]
p [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<> [Text
c])

{- | Convert a 'QualifiedClassName' to a 'FilePath' that one would expect the class file to be in
>>> suitableFilePath "java.lang.Object"
"java/lang/Object.class"

>>> suitableFilePath "Object"
"Object.class"
-}
suitableFilePath :: QualifiedClassName -> FilePath
suitableFilePath :: QualifiedClassName -> String
suitableFilePath (QualifiedClassName (PackageName [Text]
p) (ClassName Text
c)) = Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
T.intercalate Text
"/" ([Text]
p [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<> [Text
c Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
".class"])