100+ results for 'import UniqFM'
Not the results you expected?
Stats.hs (https://bitbucket.org/carter/ghc.git) Haskell · 297 lines
18 #include "nativeGen/NCG.h"
20 import qualified GraphColor as Color
21 import RegAlloc.Liveness
23 import RegAlloc.Graph.SpillCost
24 import RegAlloc.Graph.TrivColorable
25 import Instruction
32 import Outputable
33 import UniqFM
34 import UniqSet
195 $$ text "\n")
197 binLifetimeCount :: UniqFM (VirtualReg, Int) -> UniqFM (Int, Int)
198 binLifetimeCount fm
199 = let lifes = map (\l -> (l, (l, 1)))
Pretty.hs (https://github.com/mchakravarty/packages-dph.git) Haskell · 259 lines
CgExtCode.hs (https://github.com/pepeiborra/ghc.git) Haskell · 229 lines
21 newLabel,
22 newFunctionName,
23 newImport,
24 lookupLabel,
25 lookupName,
42 import OldCmm hiding( ClosureTypeInfo(..) )
44 -- import BasicTypes
45 import BlockId
47 import Module
48 import UniqFM
49 import Unique
60 -- | An environment of named things.
61 type Env = UniqFM Named
63 -- | Local declarations that are in scope during code generation.
Set.hs (https://github.com/bgamari/ghc.git) Haskell · 198 lines
5 \section[UniqSet]{Specialised sets, for things with @Uniques@}
7 Based on @UniqFMs@ (as you would expect).
9 Basically, the things need to be in class @Uniquable@.
14 module GHC.Types.Unique.Set (
15 -- * Unique set type
16 UniqSet, -- type synonym for UniqFM a
17 getUniqSet,
18 pprUniqSet,
47 ) where
49 import GHC.Prelude
51 import GHC.Types.Unique.DFM
Spill.hs (https://github.com/cpunion/ghc.git) Haskell · 338 lines
Coalesce.hs (https://github.com/mzero/ghc.git) Haskell · 88 lines
Classify.hs (https://github.com/pepeiborra/ghc.git) Haskell · 103 lines
20 import UniqSet
21 import UniqFM
22 import DataCon
23 import TyCon
24 import TypeRep
25 import Type
26 import Digraph
37 -- * tycons which can't be converted are not elements of the map
38 --
39 classifyTyCons :: UniqFM Bool -- ^type constructor conversion status
40 -> [TyCon] -- ^type constructors that need to be classified
41 -> ([TyCon], [TyCon]) -- ^tycons to be converted & not to be converted
Regs.hs (https://github.com/albertz/ghc.git) Haskell · 323 lines
24 #include "../includes/stg/MachRegs.h"
26 import RegsBase
28 import BlockId
29 import Cmm
30 import CLabel ( CLabel, mkMainCapabilityLabel )
31 import Pretty
32 import Outputable ( Outputable(..), pprPanic, panic )
33 import qualified Outputable
34 import Unique
38 import FastBool
39 import UniqFM
StgAst.hs (https://bitbucket.org/bathtub/ghcjs.git) Haskell · 103 lines
Env.hs (https://github.com/ghc/ghc.git) Haskell · 276 lines
RegInfo.hs (https://github.com/tibbe/ghc.git) Haskell · 75 lines
coredump.hs (https://github.com/khskrede/mehh.git) Haskell · 99 lines
3 import GHC
4 --GHC.Paths is available via cabal install ghc-paths
5 import GHC.Paths ( libdir )
7 import DynFlags ( defaultDynFlags )
8 import System.Environment ( getArgs )
9 import Outputable
11 import Text.JSON
12 import Text.JSON.Pretty
14 import Text.PrettyPrint.HughesPJ
16 import UniqFM
17 import Unique
Plugins.hs (https://github.com/bgamari/ghc.git) Haskell · 187 lines
4 -- the functions and types you are likely to need when writing a
5 -- plugin for GHC. So authors of plugins can probably get away simply
6 -- with saying "import GHC.Plugins".
7 --
8 -- Particularly interesting modules for plugin writers include
69 -- Plugin stuff itself
70 import GHC.Driver.Plugins
72 -- Variable naming
73 import GHC.Types.TyThing
74 import GHC.Types.PkgQual
122 -- Conflicts with UniqFM:
123 --import LazyUniqFM
124 import GHC.Data.FiniteMap
Reg.hs (https://github.com/cpunion/ghc.git) Haskell · 220 lines
Base.hs (git://github.com/ilyasergey/GHC-XAppFix.git) Haskell · 242 lines
Base.hs (https://github.com/ezyang/ghc.git) Haskell · 134 lines
Common.hs (https://github.com/ghc/ghc.git) Haskell · 118 lines
GhcPlugins.hs (https://github.com/cpunion/ghc.git) Haskell · 83 lines
29 import RdrName
30 import OccName hiding ( varName {- conflicts with Var.varName -} )
31 import Name hiding ( varName {- reexport from OccName, conflicts with Var.varName -} )
38 import Literal
39 import DataCon
40 import CoreUtils
57 import Coercion hiding {- conflict with CoreSubst -}
58 ( substTy, extendTvSubst, substCo, substTyVarBndr, lookupTyVar )
59 import TyCon
60 import TysWiredIn
69 import UniqSet
70 import UniqFM
71 -- Conflicts with UniqFM:
72 --import LazyUniqFM
73 import FiniteMap
Set.hs (https://github.com/bgamari/ghc.git) Haskell · 360 lines
47 ) where
49 import GHC.Prelude
51 import GHC.Types.Var ( Var, TyVar, CoVar, TyCoVar, Id )
52 import GHC.Types.Unique
53 import GHC.Types.Name ( Name )
54 import GHC.Types.Unique.Set
55 import GHC.Types.Unique.DSet
56 import GHC.Types.Unique.FM( disjointUFM, pluralUFM, pprUFM )
57 import GHC.Types.Unique.DFM( disjointUDFM, udfmToUfm, anyUDFM, allUDFM )
58 import GHC.Utils.Outputable (SDoc)
60 -- | A non-deterministic Variable Set
Env.hs (https://github.com/dmpots/ghc.git) Haskell · 191 lines
9 import Vectorise.Monad
10 import Vectorise.Builtins
11 import Vectorise.Type.TyConDecl
12 import Vectorise.Type.Classify
13 import Vectorise.Type.PADict
14 import Vectorise.Type.PData
15 import Vectorise.Type.PRepr
23 import DataCon
24 import TyCon
25 import Type
33 import Unique
34 import UniqFM
35 import Util
RewritePerfPlugin.hs (https://github.com/bgamari/ghc.git) Haskell · 97 lines
Coalesce.hs (https://github.com/bgamari/ghc.git) Haskell · 99 lines
4 slurpJoinMovs
5 ) where
6 import GHC.Prelude
8 import GHC.CmmToAsm.Reg.Liveness
9 import GHC.CmmToAsm.Instr
10 import GHC.Platform.Reg
12 import GHC.Cmm
13 import GHC.Data.Bag
45 -- The register with the lowest lexical name is set as the
46 -- canonical version.
47 buildAlloc :: UniqFM Reg Reg -> (Reg, Reg) -> UniqFM Reg Reg
48 buildAlloc fm (r1, r2)
49 = let rmin = min r1 r2
Base.hs (https://github.com/scpmw/ghc.git) Haskell · 132 lines
FV.hs (https://github.com/bgamari/ghc.git) Haskell · 199 lines
26 ) where
28 import GHC.Prelude
30 import GHC.Types.Var
31 import GHC.Types.Var.Set
33 -- | Predicate on possible free variables: returns @True@ iff the variable is
38 -- ~~~~~~~~~~~~~~~~~~~~~~~
39 -- When computing free variables, the order in which you get them affects
40 -- the results of floating and specialization. If you use UniqFM to collect
41 -- them and then turn that into a list, you get them in nondeterministic
42 -- order as described in Note [Deterministic UniqFM] in GHC.Types.Unique.DFM.
44 -- A naive algorithm for free variables relies on merging sets of variables.
45 -- Merging costs O(n+m) for UniqFM and for UniqDFM there's an additional log
46 -- factor. It's cheaper to incrementally add to a list and use a set to check
47 -- for duplicates.
Set.hs (https://github.com/bgamari/ghc.git) Haskell · 224 lines
36 ) where
38 import GHC.Prelude
40 import GHC.Types.Name
41 import GHC.Data.OrdList
42 import GHC.Types.Unique.Set
43 import Data.List (sortBy)
45 {-
100 -- This only works for Names that originate in the source code or have been
101 -- tidied.
102 -- See Note [Deterministic UniqFM] to learn about nondeterminism
103 nameSetElemsStable :: NameSet -> [Name]
104 nameSetElemsStable ns =
UnVarGraph.hs (https://github.com/typelead/eta.git) Haskell · 136 lines
SpillCost.hs (https://github.com/mzero/ghc.git) Haskell · 278 lines
GraphBase.hs (https://github.com/mzero/ghc.git) Haskell · 111 lines
16 import UniqSet
17 import UniqFM
45 = Graph {
46 -- | All active nodes in the graph.
47 graphMap :: UniqFM (Node k cls color) }
57 -- | Modify the finite map holding the nodes in the graph.
58 graphMapModify
59 :: (UniqFM (Node k cls color) -> UniqFM (Node k cls color))
60 -> Graph k cls color -> Graph k cls color
Base.hs (https://github.com/pepeiborra/ghc.git) Haskell · 206 lines
GraphPpr.hs (https://github.com/mzero/ghc.git) Haskell · 169 lines
Map.hs (https://github.com/bgamari/ghc.git) Haskell · 214 lines
5 {-# OPTIONS_GHC -Wall #-}
7 -- Like 'UniqFM', these are maps for keys which are Uniquable.
8 -- Unlike 'UniqFM', these maps also remember their keys, which
47 ) where
49 import GHC.Prelude
51 import GHC.Types.Unique.FM
53 import GHC.Types.Unique
54 import GHC.Utils.Outputable
56 import Data.Semigroup as Semi ( Semigroup(..) )
57 import Data.Coerce
ListSetOps.hs (https://github.com/typelead/eta.git) Haskell · 186 lines
21 ) where
23 import Eta.Utils.Outputable
24 import Eta.BasicTypes.Unique
25 import Eta.Utils.UniqFM
26 import Eta.Utils.Util
28 import Data.List
30 #include "HsVersions.h"
175 equivClassesByUniq :: (a -> Unique) -> [a] -> [[a]]
176 -- NB: it's *very* important that if we have the input list [a,b,c],
177 -- where a,b,c all have the same unique, then we get back the list
178 -- [a,b,c]
UniqFM.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 233 lines
110 -- Bindings in right argument shadow those in the left
111 plusUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
113 plusUFM_C :: (elt -> elt -> elt)
118 intersectUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
119 intersectUFM_C :: (elt1 -> elt2 -> elt3)
120 -> UniqFM elt1 -> UniqFM elt2 -> UniqFM elt3
122 foldUFM :: (elt -> a -> a) -> a -> UniqFM elt -> a
131 elemUFM_Directly:: Unique -> UniqFM elt -> Bool
133 splitUFM :: Uniquable key => UniqFM elt -> key -> (UniqFM elt, Maybe elt, UniqFM elt)
134 -- Splits a UFM into things less than, equal to, and greater than the key
135 lookupUFM :: Uniquable key => UniqFM elt -> key -> Maybe elt
Ops.hs (https://github.com/bgamari/ghc.git) Haskell · 699 lines
43 import GHC.Utils.Outputable
44 import GHC.Utils.Panic
45 import GHC.Types.Unique
46 import GHC.Types.Unique.Set
47 import GHC.Types.Unique.FM
49 import Data.List (mapAccumL, sortBy)
678 :: Uniquable k
679 => (a -> a) -> a -> k
680 -> UniqFM k a -> UniqFM k a
682 adjustWithDefaultUFM f def k map
691 :: Uniquable k
692 => (a -> a)
693 -> k -> UniqFM k a -> UniqFM k a
695 adjustUFM_C f k map
beanshell.xml (https://jedit.svn.sourceforge.net/svnroot/jedit) XML · 103 lines
StgCmmExtCode.hs (git://github.com/ghc/ghc.git) Haskell · 249 lines
FamInst.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 213 lines
Types.hs (https://github.com/scpmw/ghc.git) Haskell · 212 lines
Annotations.hs (https://github.com/bgamari/ghc.git) Haskell · 140 lines
Env.hs (https://github.com/bgamari/ghc.git) Haskell · 205 lines
Reg.hs (https://github.com/bgamari/ghc.git) Haskell · 239 lines
27 where
29 import GHC.Prelude
31 import GHC.Utils.Outputable
32 import GHC.Utils.Panic
33 import GHC.Types.Unique
34 import GHC.Builtin.Uniques
35 import GHC.Platform.Reg.Class
188 -- We like to have Uniques for Reg so that we can make UniqFM and UniqSets
189 -- in the register allocator.
190 instance Uniquable Reg where
GraphPpr.hs (https://github.com/typelead/eta.git) Haskell · 170 lines
UniqSet.hs (https://github.com/typelead/eta.git) Haskell · 210 lines
52 ) where
54 import Eta.Utils.UniqFM
55 import Eta.BasicTypes.Unique
56 import Data.Coerce
57 import Eta.Utils.Outputable
59 import Data.Data
60 #if __GLASGOW_HASKELL__ >= 801
61 import qualified Data.Semigroup
62 #endif
106 nonDetKeysUniqSet :: UniqSet elt -> [Unique]
108 -- See Note [Deterministic UniqFM] to learn about nondeterminism.
109 -- If you use this please provide a justification why it doesn't introduce
110 -- nondeterminism.
GhcPlugins.hs (https://github.com/typelead/eta.git) Haskell · 113 lines
57 -- Variable naming
58 import Eta.BasicTypes.RdrName
59 import Eta.BasicTypes.OccName hiding ( varName {- conflicts with Var.varName -} )
60 import Eta.BasicTypes.Name hiding ( varName {- reexport from OccName, conflicts with Var.varName -} )
61 import Eta.BasicTypes.Var
83 -- Important GHC types
84 import Eta.BasicTypes.Module
85 import Eta.Types.Type hiding {- conflict with CoreSubst -}
99 import Eta.Utils.UniqSet
100 import Eta.Utils.UniqFM
101 -- Conflicts with UniqFM:
102 --import LazyUniqFM
103 import Eta.Utils.FiniteMap
Env.hs (https://github.com/raeez/ghc.git) Haskell · 190 lines
9 import Vectorise.Monad
10 import Vectorise.Builtins
11 import Vectorise.Type.TyConDecl
12 import Vectorise.Type.Classify
13 import Vectorise.Type.PADict
21 import CoreUtils
22 import CoreUnfold
23 import DataCon
28 import Id
29 import MkId
30 import NameEnv
32 import Unique
33 import UniqFM
34 import Util
Base.hs (https://github.com/bgamari/ghc.git) Haskell · 188 lines
Env.hs (https://github.com/bgamari/ghc.git) Haskell · 145 lines
NameEnv.hs (https://github.com/typelead/eta.git) Haskell · 114 lines
StackMap.hs (https://github.com/pepeiborra/ghc.git) Haskell · 72 lines
Stats.hs (https://github.com/bgamari/ghc.git) Haskell · 91 lines
UniqDSet.hs (https://github.com/typelead/eta.git) Haskell · 106 lines
5 --
6 -- Based on @UniqDFMs@ (as you would expect).
7 -- See Note [Deterministic UniqFM] in UniqDFM for explanation why we need it.
8 --
9 -- Basically, the things need to be in class @Uniquable@.
11 module Eta.Utils.UniqDSet (
12 -- * Unique set type
13 UniqDSet, -- type synonym for UniqFM a
15 -- ** Manipulating these sets
33 ) where
35 import Eta.Utils.UniqDFM
36 import Eta.Utils.UniqSet
37 import Eta.BasicTypes.Unique
39 type UniqDSet a = UniqDFM a
FilePropertiesDialog.java
(https://jedit.svn.sourceforge.net/svnroot/jedit)
Java · 333 lines
✨ Summary
This Java code creates a graphical user interface (GUI) for managing file properties, such as name, path, last modified date, and permissions. It allows users to rename files, view and modify file attributes, and cancel changes. The GUI is designed to be simple and easy to use, with features like auto-saving the window’s geometry and focus on the first visible element.
This Java code creates a graphical user interface (GUI) for managing file properties, such as name, path, last modified date, and permissions. It allows users to rename files, view and modify file attributes, and cancel changes. The GUI is designed to be simple and easy to use, with features like auto-saving the window’s geometry and focus on the first visible element.
22 package org.gjt.sp.jedit.gui;
24 //{{{ Imports
25 import java.io.File;
27 import java.awt.BorderLayout;
28 import java.awt.GridLayout;
29 import java.awt.event.ActionEvent;
30 import java.awt.event.ActionListener;
31 import java.text.SimpleDateFormat;
32 import java.util.Date;
34 import javax.swing.*;
35 import javax.swing.border.Border;
users-guide.xsl (https://jedit.svn.sourceforge.net/svnroot/jedit) Extensible Stylesheet Language Transformations · 284 lines
GraphBase.hs (https://github.com/typelead/eta.git) Haskell · 105 lines
15 import Eta.Utils.UniqSet
16 import Eta.Utils.UniqFM
44 = Graph {
45 -- | All active nodes in the graph.
46 graphMap :: UniqFM (Node k cls color) }
56 -- | Modify the finite map holding the nodes in the graph.
57 graphMapModify
58 :: (UniqFM (Node k cls color) -> UniqFM (Node k cls color))
59 -> Graph k cls color -> Graph k cls color
GraphOps.hs (https://github.com/typelead/eta.git) Haskell · 677 lines
25 import Eta.Utils.UniqSet
26 import Eta.Utils.UniqFM
28 import Data.List hiding (union)
29 import Data.Maybe
31 -- | Lookup a node from the graph.
657 :: Uniquable k
658 => (a -> a) -> a -> k
659 -> UniqFM a -> UniqFM a
661 adjustWithDefaultUFM f def k map
670 :: Uniquable k
671 => (a -> a)
672 -> k -> UniqFM a -> UniqFM a
674 adjustUFM_C f k map
TrieMap.hs (https://github.com/typelead/eta.git) Haskell · 839 lines
15 ) where
17 import Eta.Core.CoreSyn
18 import Eta.Types.Coercion
19 import Eta.BasicTypes.Literal
20 import Eta.BasicTypes.Name
21 import Eta.Types.Type
22 import Eta.Types.TypeRep
23 import Eta.Types.TyCon(TyCon)
24 import Eta.BasicTypes.Var
25 import Eta.Utils.UniqFM
26 import Eta.BasicTypes.Unique( Unique )
27 import Eta.Utils.FastString(FastString)
28 import Eta.Types.CoAxiom(CoAxiomRule(coaxrName))
DSet.hs (https://github.com/bgamari/ghc.git) Haskell · 142 lines
5 --
6 -- Based on 'UniqDFM's (as you would expect).
7 -- See Note [Deterministic UniqFM] in "GHC.Types.Unique.DFM" for explanation why we need it.
8 --
9 -- Basically, the things need to be in class 'Uniquable'.
13 module GHC.Types.Unique.DSet (
14 -- * Unique set type
15 UniqDSet, -- type synonym for UniqFM a
16 getUniqDSet,
17 pprUniqDSet,
37 ) where
39 import GHC.Prelude
41 import GHC.Utils.Outputable
CmmLex.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 507 lines
CoreTidy.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 237 lines
ListSetOps.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 225 lines
20 ) where
22 import Outputable
23 import Unique
24 import UniqFM
25 import Util
27 import Data.List
28 \end{code}
210 \begin{code}
211 equivClassesByUniq :: (a -> Unique) -> [a] -> [[a]]
212 -- NB: it's *very* important that if we have the input list [a,b,c],
213 -- where a,b,c all have the same unique, then we get back the list
214 -- [a,b,c]
CmmCommonBlockElimZ.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 165 lines
Base.hs (https://github.com/bgamari/ghc.git) Haskell · 107 lines
13 where
15 import GHC.Prelude
17 import GHC.Types.Unique.Set
18 import GHC.Types.Unique.FM
46 = Graph {
47 -- | All active nodes in the graph.
48 graphMap :: UniqFM k (Node k cls color) }
58 -- | Modify the finite map holding the nodes in the graph.
59 graphMapModify
60 :: (UniqFM k (Node k cls color) -> UniqFM k (Node k cls color))
61 -> Graph k cls color -> Graph k cls color
VarSet.hs (https://github.com/typelead/eta.git) Haskell · 348 lines
46 #include "HsVersions.h"
48 import Eta.BasicTypes.Var ( Var, TyVar, CoVar, TyCoVar, Id )
49 import Eta.BasicTypes.Unique
50 import Eta.BasicTypes.Name ( Name )
51 import Eta.Utils.UniqSet
52 import Eta.Utils.UniqDSet
53 import Eta.Utils.UniqFM( disjointUFM, pluralUFM, pprUFM )
54 import Eta.Utils.UniqDFM( disjointUDFM, udfmToUfm, anyUDFM, allUDFM )
55 import Eta.Utils.Outputable (SDoc)
57 -- | A non-deterministic Variable Set
58 --
59 -- A non-deterministic set of variables.
60 -- See Note [Deterministic UniqFM] in UniqDFM for explanation why it's not
61 -- deterministic and why it matters. Use DVarSet if the set eventually
62 -- gets converted into a list or folded over in a way where the order
RewritePlugin.hs (https://github.com/bgamari/ghc.git) Haskell · 87 lines
NameSet.hs (https://github.com/typelead/eta.git) Haskell · 209 lines
29 ) where
31 import Eta.BasicTypes.Name
32 import Eta.Utils.UniqSet
33 import Data.List ( sortBy )
35 {-
92 -- This only works for Names that originate in the source code or have been
93 -- tidied.
94 -- See Note [Deterministic UniqFM] to learn about nondeterminism
95 nameSetElemsStable :: NameSet -> [Name]
96 nameSetElemsStable ns =
Stats.hs (https://github.com/ezyang/ghc.git) Haskell · 88 lines
Stats.hs (https://github.com/dagit/ghc.git) Haskell · 86 lines
7 where
9 import RegAlloc.Linear.Base
10 import RegAlloc.Liveness
11 import Instruction
13 import UniqFM
14 import Outputable
16 import Data.List
17 import State
19 -- | Build a map of how many times each reg was alloced, clobbered, loaded etc.
20 binSpillReasons
21 :: [SpillReason] -> UniqFM [Int]
23 binSpillReasons reasons
Stats.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 288 lines
23 import RegAlloc.Graph.SpillCost
24 import RegAlloc.Graph.TrivColorable
25 import Instruction
27 import Reg
28 import TargetReg
30 import Cmm
31 import Outputable
32 import UniqFM
33 import UniqSet
194 $$ text "\n")
196 binLifetimeCount :: UniqFM (VirtualReg, Int) -> UniqFM (Int, Int)
197 binLifetimeCount fm
198 = let lifes = map (\l -> (l, (l, 1)))
RegInfo.hs (https://github.com/bgamari/ghc.git) Haskell · 72 lines
ExtCode.hs (https://github.com/bgamari/ghc.git) Haskell · 260 lines
Plugin.hs (git://pkgs.fedoraproject.org/ghc) Haskell · 83 lines
Base.hs (https://github.com/nominolo/ghc.git) Haskell · 137 lines
Stats.hs (https://github.com/nominolo/ghc.git) Haskell · 88 lines
RegInfo.hs (https://github.com/ezyang/ghc.git) Haskell · 69 lines
StackMap.hs (https://github.com/bgamari/ghc.git) Haskell · 61 lines
RegInfo.hs (https://github.com/axman6/ghc.git) Haskell · 88 lines
Annotations.hs (git://github.com/ghc/ghc.git) Haskell · 133 lines
Env.hs (https://github.com/bgamari/ghc.git) Haskell · 100 lines
28 ) where
30 import GHC.Prelude
32 import GHC.Types.Unique.FM
33 import GHC.Types.Unique.DFM
34 import GHC.Data.Maybe
35 import GHC.Data.FastString
38 -- | A non-deterministic set of FastStrings.
39 -- See Note [Deterministic UniqFM] in "GHC.Types.Unique.DFM" for explanation why it's not
40 -- deterministic and why it matters. Use DFastStringEnv if the set eventually
41 -- gets converted into a list or folded over in a way where the order
Show.hs (https://github.com/mikeizbicki/HerbiePlugin.git) Haskell · 160 lines
FV.hs (https://github.com/typelead/eta.git) Haskell · 210 lines
28 ) where
30 import Eta.BasicTypes.Var
31 import Eta.BasicTypes.VarSet
38 -- ~~~~~~~~~~~~~~~~~~~~~~~
39 -- When computing free variables, the order in which you get them affects
40 -- the results of floating and specialization. If you use UniqFM to collect
41 -- them and then turn that into a list, you get them in nondeterministic
42 -- order as described in Note [Deterministic UniqFM] in UniqDFM.
44 -- A naive algorithm for free variables relies on merging sets of variables.
45 -- Merging costs O(n+m) for UniqFM and for UniqDFM there's an additional log
46 -- factor. It's cheaper to incrementally add to a list and use a set to check
47 -- for duplicates.
54 -- so that the list doesn't have duplicates
55 -- For explanation of why using `VarSet` is not deterministic see
56 -- Note [Deterministic UniqFM] in UniqDFM.
57 -> ([Var], VarSet)
BlockId.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 160 lines
11 ) where
13 import CLabel
14 import IdInfo
15 import Maybes
16 import Name
17 import Outputable
18 import UniqFM
19 import Unique
20 import UniqSet
22 ----------------------------------------------------------------
58 -- Block environments: Id blocks
59 newtype BlockEnv a = BlockEnv (UniqFM {- id -} a)
61 instance Outputable a => Outputable (BlockEnv a) where
UnblockingMessageImpl.java
(http://mobicents.googlecode.com/svn/trunk/)
Java · 131 lines
✨ Summary
This Java class implements an UnblockingMessage, a type of message in the ISUP (Intelligent Switching System) protocol. It extends another class and provides specific implementations for decoding and processing message parameters. The class includes methods for getting the message type, checking mandatory parameter presence, and handling optional parameters, which are not supported in this implementation.
This Java class implements an UnblockingMessage, a type of message in the ISUP (Intelligent Switching System) protocol. It extends another class and provides specific implementations for decoding and processing message parameters. The class includes methods for getting the message type, checking mandatory parameter presence, and handling optional parameters, which are not supported in this implementation.
29 package org.mobicents.protocols.ss7.isup.impl.message;
31 import java.util.Map;
32 import java.util.Set;
34 import org.mobicents.protocols.ss7.isup.ISUPParameterFactory;
35 import org.mobicents.protocols.ss7.isup.ParameterException;
36 import org.mobicents.protocols.ss7.isup.impl.message.parameter.MessageTypeImpl;
37 import org.mobicents.protocols.ss7.isup.message.UnblockingMessage;
38 import org.mobicents.protocols.ss7.isup.message.parameter.MessageType;
40 /**
Utils.hs (https://github.com/bgamari/ghc.git) Haskell · 58 lines
3 where
5 {- Note [UniqFM and the register allocator]
6 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7 Before UniqFM had a key type the register allocator
51 -- These should hopefully be zero cost.
53 toRegMap :: UniqFM VirtualReg elt -> UniqFM Reg elt
54 toRegMap = unsafeCastUFMKey
56 toVRegMap :: UniqFM Reg elt -> UniqFM VirtualReg elt
57 toVRegMap = unsafeCastUFMKey
GhcUtils.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 247 lines
21 import Data.Foldable hiding (concatMap)
22 import Data.Traversable
23 import Distribution.Compat.ReadP
24 import Distribution.Text
26 import Exception
27 import Outputable
28 import Name
29 import Packages
30 import Module
31 import RdrName (GlobalRdrEnv)
35 import HscTypes
36 import UniqFM
37 import GHC
VarSet.hs (git://github.com/ghc/ghc.git) Haskell · 335 lines
45 #include "HsVersions.h"
47 import Var ( Var, TyVar, CoVar, TyCoVar, Id )
48 import Unique
49 import Name ( Name )
50 import UniqSet
51 import UniqDSet
52 import UniqFM( disjointUFM, pluralUFM, pprUFM )
53 import UniqDFM( disjointUDFM, udfmToUfm )
54 import Outputable (SDoc)
56 -- | A non-deterministic Variable Set
57 --
58 -- A non-deterministic set of variables.
59 -- See Note [Deterministic UniqFM] in UniqDFM for explanation why it's not
60 -- deterministic and why it matters. Use DVarSet if the set eventually
61 -- gets converted into a list or folded over in a way where the order
DebugGhcAST.hs (https://github.com/haskell-tools/haskell-tools.git) Haskell · 393 lines
12 import BasicTypes
13 import BooleanFormula (BooleanFormula(..))
14 import Coercion (Var(..), Role(..))
15 import ConLike (ConLike(..))
16 import CoreSyn (Tickish(..))
18 import ForeignCall
19 import GHC
20 import Module (Module(..), ModuleName(..))
21 import OccName (OccName(..))
22 import Outputable (Outputable(..), showSDocUnsafe)
23 import PatSyn (PatSyn(..))
25 import TcEvidence
26 import UniqFM (UniqFM(..))
27 import UniqSet (UniqSet(..))
Annotations.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 102 lines
19 import Name
20 import Module ( Module )
21 import Outputable
22 import UniqFM
23 import Serialized
24 import Unique
26 import Data.Typeable
27 import Data.Maybe
28 import Data.Word ( Word8 )
69 -- | A collection of annotations
70 newtype AnnEnv = MkAnnEnv (UniqFM [Serialized])
71 -- Can't use a type synonym or we hit bug #2412 due to source import
CgExtCode.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 230 lines
21 newLabel,
22 newFunctionName,
23 newImport,
24 lookupLabel,
25 lookupName,
42 import Cmm
44 -- import BasicTypes
45 import BlockId
47 import Module
48 import UniqFM
49 import Unique
60 -- | An environment of named things.
61 type Env = UniqFM Named
63 -- | Local declarations that are in scope during code generation.
Base.hs (https://github.com/kgardas/ghc.git) Haskell · 136 lines
Annotations.hs (https://github.com/typelead/eta.git) Haskell · 133 lines
19 import Eta.Utils.Binary
20 import Eta.BasicTypes.Module ( Module )
21 import Eta.BasicTypes.Name
22 import Eta.Utils.Outputable
23 import Eta.Utils.UniqFM
24 import Eta.BasicTypes.Unique
25 import Eta.Serialized
26 import Control.Monad
27 import Data.Maybe
28 import Data.Typeable
29 import Data.Word ( Word8 )
cookie.py
(https://code.google.com/p/mango-py/)
Python · 153 lines
✨ Summary
This Django code implements a custom storage system for storing and retrieving messages, which are used to display notifications to users. It stores messages in a cookie on the client-side, allowing them to be retrieved and displayed dynamically. The code includes encryption and hashing to ensure data integrity and security.
This Django code implements a custom storage system for storing and retrieving messages, which are used to display notifications to users. It stores messages in a cookie on the client-side, allowing them to be retrieved and displayed dynamically. The code includes encryption and hashing to ensure data integrity and security.
1 from django.conf import settings
2 from django.contrib.messages import constants
3 from django.contrib.messages.storage.base import BaseStorage, Message
4 from django.http import SimpleCookie
5 from django.utils import simplejson as json
6 from django.utils.crypto import salted_hmac, constant_time_compare
Interpreter.hs (git://github.com/iand675/Zoom.git) Haskell · 117 lines
5 import PackageConfig
6 import UniqFM
7 import qualified HscTypes as GHC
46 , searchPath := ["./tasks"]]
47 loadLocalTaskModules
48 qualified <- importZoomTasks imports
49 taskStrings <- availableTasks qualified
50 tasks <- mapM (\x -> interpret x (as :: Task s)) taskStrings
70 importZoomTasks :: [String] -> Interpreter [ModuleName]
71 importZoomTasks imports = do
72 localModules <- getLoadedModules
73 globalModules <- getAvailableModules
86 runZoomInterpreter :: (Typeable s, Retrieve s) => [String] -> IO (Either InterpreterError [(String, Task s)])
87 runZoomInterpreter imports = runInterpreter $ interpreterMain imports
Bag.hs (https://github.com/facebookincubator/retrie.git) Haskell · 164 lines
121 newtype FSEnv a =
122 FSEnv { _unFSEnv :: UniqFM a } -- this is the UniqFM below, NOT GHC's UniqFM
123 deriving (Functor)
140 ------------------------------------------------------------------------
142 newtype UniqFM a = UniqFM { unUniqFM :: GHC.UniqFM [a] }
143 deriving (Functor)
149 mEmpty = UniqFM GHC.emptyUFM
151 mUnion :: UniqFM a -> UniqFM a -> UniqFM a
152 mUnion (UniqFM m1) (UniqFM m2) = UniqFM $ GHC.plusUFM_C (++) m1 m2
154 mAlter :: AlphaEnv -> Quantifiers -> Key UniqFM -> A a -> UniqFM a -> UniqFM a
155 mAlter _ _ k f (UniqFM m) = UniqFM $ GHC.alterUFM (toAList f) m k
SpillCost.hs
(git://github.com/ghc/ghc.git)
Haskell · 292 lines
✨ Summary
This Haskell code is part of a compiler’s allocator, specifically for handling spills (temporary storage) of registers during compilation. It calculates the cost of spilling a live range, which determines whether to spill from the inside out or outside in, and how to allocate stack slots. The code uses graph theory and data structures like graphs, maps, and sets to efficiently manage register lifetimes and conflicts.
This Haskell code is part of a compiler’s allocator, specifically for handling spills (temporary storage) of registers during compilation. It calculates the cost of spilling a live range, which determines whether to spill from the inside out or outside in, and how to allocate stack slots. The code uses graph theory and data structures like graphs, maps, and sets to efficiently manage register lifetimes and conflicts.
Classify.hs
(git://github.com/ghc/ghc.git)
Haskell · 129 lines
✨ Summary
The classifyTyCons function classifies a list of type constructors into three categories: those that must be vectorized, those that need not be vectorized but could be, and those that cannot be converted. It uses a graph-based approach to identify mutually recursive groups of tycons and determines their conversion status based on the presence of parallel arrays and other factors.
The classifyTyCons function classifies a list of type constructors into three categories: those that must be vectorized, those that need not be vectorized but could be, and those that cannot be converted. It uses a graph-based approach to identify mutually recursive groups of tycons and determines their conversion status based on the presence of parallel arrays and other factors.
FastStringEnv.hs (git://github.com/ghc/ghc.git) Haskell · 96 lines
28 ) where
30 import UniqFM
31 import UniqDFM
32 import Maybes
33 import FastString
36 -- | A non-deterministic set of FastStrings.
37 -- See Note [Deterministic UniqFM] in UniqDFM for explanation why it's not
38 -- deterministic and why it matters. Use DFastStringEnv if the set eventually
39 -- gets converted into a list or folded over in a way where the order
40 -- changes the generated code.
41 type FastStringEnv a = UniqFM a -- Domain is FastString
43 emptyFsEnv :: FastStringEnv a
SpillCost.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 278 lines
NameSet.hs (git://github.com/ghc/ghc.git) Haskell · 214 lines
34 #include "HsVersions.h"
36 import Name
37 import UniqSet
38 import UniqFM
39 import Data.List (sortBy)
94 -- This only works for Names that originate in the source code or have been
95 -- tidied.
96 -- See Note [Deterministic UniqFM] to learn about nondeterminism
97 nameSetElemsStable :: NameSet -> [Name]
98 nameSetElemsStable ns =
Types.hs (https://github.com/bgamari/ghc.git) Haskell · 74 lines
NameEnv.hs (git://github.com/ghc/ghc.git) Haskell · 152 lines
CmmParse.hs (git://pkgs.fedoraproject.org/ghc) Haskell · 2919 lines
CmmLex.hs (git://pkgs.fedoraproject.org/ghc) Haskell · 518 lines
19 import SrcLoc
20 import UniqFM
21 import StringBuffer
27 import Data.Word
28 import Data.Char
30 #if __GLASGOW_HASKELL__ >= 603
34 #endif
35 #if __GLASGOW_HASKELL__ >= 503
36 import Data.Array
37 import Data.Char (ord)
168 ( "return", CmmT_return ),
169 ( "returns", CmmT_returns ),
170 ( "import", CmmT_import ),
171 ( "switch", CmmT_switch ),
172 ( "case", CmmT_case ),
Types.hs (https://github.com/facebookincubator/retrie.git) Haskell · 65 lines
NameEnv.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 84 lines
Stats.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 89 lines
UniqSet.hs (git://github.com/ghc/ghc.git) Haskell · 123 lines
5 \section[UniqSet]{Specialised sets, for things with @Uniques@}
7 Based on @UniqFMs@ (as you would expect).
9 Basically, the things need to be in class @Uniquable@.
12 module UniqSet (
13 -- * Unique set type
14 UniqSet, -- type synonym for UniqFM a
16 -- ** Manipulating these sets
33 ) where
35 import UniqFM
36 import Unique
73 ************************************************************************
74 * *
75 \subsection{Implementation using ``UniqFM''}
76 * *
77 ************************************************************************
GHC.hs (https://github.com/facebookincubator/retrie.git) Haskell · 211 lines
Function.hs (https://github.com/facebookincubator/retrie.git) Haskell · 168 lines
15 import Control.Monad.State.Lazy
16 import Data.List
17 import Data.Maybe
18 import Data.Traversable
20 import Retrie.ExactPrint
21 import Retrie.Expr
22 import Retrie.GHC
35 [ do
36 fe <- mkLocatedHsVar fRdrName
37 imps <- getImports dir (hsmodName m)
38 (fName,) . concat <$>
39 forM (unLoc $ mg_alts $ fun_matches f) (matchToRewrites fe imps dir)
56 getImports RightToLeft (Just (L _ mn)) = -- See Note [fold only]
57 lift $ liftIO $ parseImports ["import " ++ moduleNameString mn]
58 getImports _ _ = return mempty
GraphBase.hs
(git://github.com/ghc/ghc.git)
Haskell · 106 lines
✨ Summary
This Haskell code defines a graph coloring system, allowing for the creation of graphs with nodes that have specific classes, exclusions, and preferences for colors. It provides functions to initialize an empty graph, modify its node map, create new nodes, and check if a node is trivially colorable based on its neighbors and exclusions.
This Haskell code defines a graph coloring system, allowing for the creation of graphs with nodes that have specific classes, exclusions, and preferences for colors. It provides functions to initialize an empty graph, modify its node map, create new nodes, and check if a node is trivially colorable based on its neighbors and exclusions.
15 import UniqSet
16 import UniqFM
44 = Graph {
45 -- | All active nodes in the graph.
46 graphMap :: UniqFM (Node k cls color) }
56 -- | Modify the finite map holding the nodes in the graph.
57 graphMapModify
58 :: (UniqFM (Node k cls color) -> UniqFM (Node k cls color))
59 -> Graph k cls color -> Graph k cls color
Coalesce.hs (http://picorec.googlecode.com/svn/trunk/) Haskell · 89 lines
UniqSet.lhs (http://picorec.googlecode.com/svn/trunk/) Haskell · 116 lines
5 \section[UniqSet]{Specialised sets, for things with @Uniques@}
7 Based on @UniqFMs@ (as you would expect).
9 Basically, the things need to be in class @Uniquable@.
12 module UniqSet (
13 -- * Unique set type
14 UniqSet, -- type synonym for UniqFM a
16 -- ** Manipulating these sets
34 ) where
36 import UniqFM
37 import Unique
76 %************************************************************************
77 %* *
78 \subsection{Implementation using ``UniqFM''}
79 %* *
80 %************************************************************************
SpillClean.hs
(git://github.com/ghc/ghc.git)
Haskell · 612 lines
✨ Summary
This Haskell code implements a spill cleaner for a compiler, which is responsible for allocating virtual registers to physical registers during compilation. It manages associations between store locations (stack slots and registers) based on their values, allowing it to identify and eliminate unnecessary allocations. The code provides functions for adding, deleting, and checking associations, as well as finding the reflection transitive closure of an association.
This Haskell code implements a spill cleaner for a compiler, which is responsible for allocating virtual registers to physical registers during compilation. It manages associations between store locations (stack slots and registers) based on their values, allowing it to identify and eliminate unnecessary allocations. The code provides functions for adding, deleting, and checking associations, as well as finding the reflection transitive closure of an association.
GraphOps.hs
(git://github.com/ghc/ghc.git)
Haskell · 679 lines
✨ Summary
This Haskell code provides functions for manipulating graphs, specifically graph operations such as validating, coloring, and counting node conflicts. It ensures that a graph is valid by checking that all edges point to existing nodes and that no conflicting nodes have the same color. The code also allows setting the color of specific nodes and slursping out maps of node conflict counts.
This Haskell code provides functions for manipulating graphs, specifically graph operations such as validating, coloring, and counting node conflicts. It ensures that a graph is valid by checking that all edges point to existing nodes and that no conflicting nodes have the same color. The code also allows setting the color of specific nodes and slursping out maps of node conflict counts.
25 import UniqSet
26 import UniqFM
28 import Data.List hiding (union)
29 import Data.Maybe
31 -- | Lookup a node from the graph.
657 :: Uniquable k
658 => (a -> a) -> a -> k
659 -> UniqFM a -> UniqFM a
661 adjustWithDefaultUFM f def k map
670 :: Uniquable k
671 => (a -> a)
672 -> k -> UniqFM a -> UniqFM a
674 adjustUFM_C f k map
RegInfo.hs
(git://github.com/ghc/ghc.git)
Haskell · 68 lines
✨ Summary
This Haskell code defines a module for generating information about x86 registers, including virtual register types and colors associated with each register on different platforms. It uses platform-specific data to determine the color of a given register, which is then used in outputable formats. The code includes definitions for virtual register types, normal reg colors, and fake fp reg colors.
This Haskell code defines a module for generating information about x86 registers, including virtual register types and colors associated with each register on different platforms. It uses platform-specific data to determine the color of a given register, which is then used in outputable formats. The code includes definitions for virtual register types, normal reg colors, and fake fp reg colors.
NameEnv.lhs
(git://github.com/ghc/ghc.git)
Haskell · 123 lines
✨ Summary
This Haskell code defines a module for working with name environments, which are used to manage variables and their bindings in a programming language. It provides functions for creating, manipulating, and querying these environments, including adding, removing, and looking up bindings, as well as performing dependency analysis on definitions. The code is designed to be flexible and reusable.
This Haskell code defines a module for working with name environments, which are used to manage variables and their bindings in a programming language. It provides functions for creating, manipulating, and querying these environments, including adding, removing, and looking up bindings, as well as performing dependency analysis on definitions. The code is designed to be flexible and reusable.
Classify.hs (git://github.com/ilyasergey/GHC-XAppFix.git) Haskell · 117 lines
20 import UniqSet
21 import UniqFM
22 import DataCon
23 import TyCon
24 import TypeRep
25 import Type
26 import PrelNames
27 import Digraph
40 -- * tycons which can't be converted are not elements of the map
41 --
42 classifyTyCons :: UniqFM Bool -- ^type constructor conversion status
43 -> [TyCon] -- ^type constructors that need to be classified
44 -> ([TyCon], [TyCon], [TyCon]) -- ^tycons to be converted & not to be converted
TrieMap.lhs (git://github.com/ilyasergey/GHC-XAppFix.git) Haskell · 614 lines
UniqFM.lhs
(git://github.com/ghc/ghc.git)
Haskell · 275 lines
✨ Summary
This Haskell code defines a data structure UniqFM to represent an unordered map (dictionary) with unique keys, and provides various functions for manipulating and querying this data structure. The code includes functions for creating, modifying, and querying the map, as well as converting it to a list of key-value pairs. It also supports outputting the contents of the map in a human-readable format.
This Haskell code defines a data structure UniqFM to represent an unordered map (dictionary) with unique keys, and provides various functions for manipulating and querying this data structure. The code includes functions for creating, modifying, and querying the map, as well as converting it to a list of key-value pairs. It also supports outputting the contents of the map in a human-readable format.
131 -- Bindings in right argument shadow those in the left
132 plusUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
134 plusUFM_C :: (elt -> elt -> elt)
139 intersectUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
140 intersectUFM_C :: (elt1 -> elt2 -> elt3)
141 -> UniqFM elt1 -> UniqFM elt2 -> UniqFM elt3
143 foldUFM :: (elt -> a -> a) -> a -> UniqFM elt -> a
148 filterUFM_Directly :: (Unique -> elt -> Bool) -> UniqFM elt -> UniqFM elt
149 partitionUFM :: (elt -> Bool) -> UniqFM elt -> (UniqFM elt, UniqFM elt)
151 sizeUFM :: UniqFM elt -> Int
154 elemUFM_Directly:: Unique -> UniqFM elt -> Bool
156 splitUFM :: Uniquable key => UniqFM elt -> key -> (UniqFM elt, Maybe elt, UniqFM elt)
157 -- Splits a UFM into things less than, equal to, and greater than the key
158 lookupUFM :: Uniquable key => UniqFM elt -> key -> Maybe elt
FV.hs (git://github.com/ghc/ghc.git) Haskell · 200 lines
27 ) where
29 import Var
30 import VarSet
37 -- ~~~~~~~~~~~~~~~~~~~~~~~
38 -- When computing free variables, the order in which you get them affects
39 -- the results of floating and specialization. If you use UniqFM to collect
40 -- them and then turn that into a list, you get them in nondeterministic
41 -- order as described in Note [Deterministic UniqFM] in UniqDFM.
43 -- A naive algorithm for free variables relies on merging sets of variables.
44 -- Merging costs O(n+m) for UniqFM and for UniqDFM there's an additional log
45 -- factor. It's cheaper to incrementally add to a list and use a set to check
46 -- for duplicates.
53 -- so that the list doesn't have duplicates
54 -- For explanation of why using `VarSet` is not deterministic see
55 -- Note [Deterministic UniqFM] in UniqDFM.
56 -> ([Var], VarSet)
FindSymbol.hs (https://github.com/hdevtools/hdevtools.git) Haskell · 96 lines
8 import GhcMonad (liftIO)
9 #elif __GLASGOW_HASKELL__ >= 710
10 import GHC.PackageDb (exposedName)
11 import GhcMonad (liftIO)
13 import Control.Applicative ((<$>))
14 import qualified UniqFM
15 #endif
17 import Control.Exception
18 import Control.Monad (filterM)
19 import Data.List (find, nub)
20 import Data.Maybe (catMaybes, isJust)
21 import Exception (ghandle)
23 import qualified GHC
24 import qualified Packages as PKG
NewRecordDelegate.java
(http://mobiledatanow.googlecode.com/svn/trunk/)
Java · 79 lines
✨ Summary
This Java class, NewRecordDelegate, is a delegate used by an MdnHtmlServlet to handle actions related to creating new records in a data view. It validates user state and menu action, creates a record for the data view if valid, sets it into the user state, and then delegates to another delegate (EditRecordDelegate) to show the created record.
This Java class, NewRecordDelegate, is a delegate used by an MdnHtmlServlet to handle actions related to creating new records in a data view. It validates user state and menu action, creates a record for the data view if valid, sets it into the user state, and then delegates to another delegate (EditRecordDelegate) to show the created record.
6 package wsl.mdn.html;
8 import wsl.fw.servlet.ServletBase;
9 import wsl.fw.util.Util;
10 import wsl.fw.resource.ResId;
11 import wsl.mdn.guiconfig.*;
12 import wsl.mdn.dataview.*;
14 import java.io.IOException;
15 import javax.servlet.ServletException;
17 //------------------------------------------------------------------------------
MdnClientCell.java
(http://mobiledatanow.googlecode.com/svn/trunk/)
Java · 104 lines
✨ Summary
This Java class, MdnClientCell, extends the TD class from Apache ECS and represents a client cell element in HTML. It provides constructors for creating instances with different parameters, including a blank constructor, string constructor, boolean constructor, and an element constructor. The class also includes accessors to set and get the title and help URL of the client cell.
This Java class, MdnClientCell, extends the TD class from Apache ECS and represents a client cell element in HTML. It provides constructors for creating instances with different parameters, including a blank constructor, string constructor, boolean constructor, and an element constructor. The class also includes accessors to set and get the title and help URL of the client cell.
NamedNativeQuery.java
(http://gwt-ent.googlecode.com/svn/trunk/)
Java · 48 lines
✨ Summary
This Java code defines an annotation @NamedNativeQuery that can be applied to a type (e.g., class). It specifies metadata for a native query, including its name, query text, hints, result class, and optional resultSetMapping. The annotation is intended for use with the Java Persistence API (JPA) and has runtime retention, allowing it to be inspected at runtime.
This Java code defines an annotation @NamedNativeQuery that can be applied to a type (e.g., class). It specifies metadata for a native query, including its name, query text, hints, result class, and optional resultSetMapping. The annotation is intended for use with the Java Persistence API (JPA) and has runtime retention, allowing it to be inspected at runtime.
AssemblyInfo.vb
(https://cfx.svn.codeplex.com/svn)
Visual Basic · 36 lines
✨ Summary
This Visual Basic code defines metadata for an assembly, including its title, company, and version information. It also specifies that the types in this assembly are not visible to COM components and provides a GUID for the typelib if the project is exposed to COM. The AssemblyVersion and AssemblyFileVersion values specify the version of the assembly.
This Visual Basic code defines metadata for an assembly, including its title, company, and version information. It also specifies that the types in this assembly are not visible to COM components and provides a GUID for the typelib if the project is exposed to COM. The AssemblyVersion and AssemblyFileVersion values specify the version of the assembly.