text:
namespace flag_descriptions {

const char kAdaptiveSuggestionsCountName[] = "Omnibox adaptive suggestions";
const char kAdaptiveSuggestionsCountDescription[] =
    "Allows Omnibox to dynamically adjust number of offered suggestions to "
    "fill in the space between Omnibox and the soft keyboard.";

const char kAppStoreRatingName[] = "Enable the App Store Rating promo.";
const char kAppStoreRatingDescription[] =
    "When enabled, App Store Rating promo will be presented to eligible "
    "users.";

const char kAutofillBrandingIOSName[] = "Autofill Branding on iOS";
const char kAutofillBrandingIOSDescription[] =
    "Adds the Chrome logo in the form input suggestions bar. Full color by "
    "default.";

const char kAutofillCreditCardUploadName[] =
    "Offers uploading Autofilled credit cards";
const char kAutofillCreditCardUploadDescription[] =
    "Offers uploading Autofilled credit cards to Google Payments after form "
    "submission.";

const char kAutofillEnableNewCardUnmaskPromptViewName[] =
    "Enable the new Card Unmask Prompt View for Autofill.";
const char kAutofillEnableNewCardUnmaskPromptViewDescription[] =
    "Displays the new autofill prompt for entering a credit card's CVC and "
    "(optional) expiration date.";

const char kAutofillEnableRankingFormulaName[] =
    "Enable new Autofill suggestion ranking formula";
const char kAutofillEnableRankingFormulaDescription[] =
    "When enabled, Autofill will use a new ranking formula to rank Autofill "
    "data model suggestions such as credit cards or profiles";

const char kAutofillEnableRemadeDownstreamMetricsName[] =
    "Enable remade Autofill Downstream metrics logging";
const char kAutofillEnableRemadeDownstreamMetricsDescription[] =
    "When enabled, some extra metrics logging for Autofill Downstream will "
    "start.";

const char kAutofillEnableCardProductNameName[] =
    "Enable showing card product name";
const char kAutofillEnableCardProductNameDescription[] =
    "When enabled, card product name (instead of issuer network) will be shown "
    "in Payments UI.";

const char kAutofillEnforceDelaysInStrikeDatabaseName[] =
    "Enforce delay between offering Autofill opportunities in the strike "
    "database";
const char kAutofillEnforceDelaysInStrikeDatabaseDescription[] =
    "When enabled, if previous Autofill feature offer was declined, "
    "Chrome will wait for sometime before showing the offer again.";

const char kAutofillFillMerchantPromoCodeFieldsName[] =
    "Enable Autofill of promo code fields in forms";
const char kAutofillFillMerchantPromoCodeFieldsDescription[] =
    "When enabled, Autofill will attempt to fill merchant promo/coupon/gift "
    "code fields when data is available.";

const char kAutofillIOSDelayBetweenFieldsName[] = "Autofill delay";
const char kAutofillIOSDelayBetweenFieldsDescription[] =
    "Delay between the different fields of a form being autofilled. In "
    "milliseconds.";

const char kAutofillParseIBANFieldsName[] = "Parse IBAN fields in forms";
const char kAutofillParseIBANFieldsDescription[] =
    "When enabled, Autofill will attempt to find International Bank Account "
    "Number (IBAN) fields when parsing forms.";

const char kAutofillParseVcnCardOnFileStandaloneCvcFieldsName[] =
    "Parse standalone CVC fields for VCN card on file in forms";
const char kAutofillParseVcnCardOnFileStandaloneCvcFieldsDescription[] =
    "When enabled, Autofill will attempt to find standalone CVC fields for VCN "
    "card on file when parsing forms.";

const char kAutofillPruneSuggestionsName[] = "Autofill Prune Suggestions";
const char kAutofillPruneSuggestionsDescription[] =
    "Further limits the number of suggestions in the Autofill dropdown.";

const char kAutofillSaveCardDismissOnNavigationName[] =
    "Save Card Dismiss on Navigation";
const char kAutofillSaveCardDismissOnNavigationDescription[] =
    "Dismisses the Save Card Infobar on a user initiated Navigation, other "
    "than one caused by submitted form.";

const char kAutofillUpstreamAllowAdditionalEmailDomainsName[] =
    "Allow Autofill credit card upload save for select non-Google-based "
    "accounts";
const char kAutofillUpstreamAllowAdditionalEmailDomainsDescription[] =
    "When enabled, credit card upload is offered if the user's logged-in "
    "account's domain is from a common email provider.";

const char kAutofillUpstreamAllowAllEmailDomainsName[] =
    "Allow Autofill credit card upload save for all non-Google-based accounts";
const char kAutofillUpstreamAllowAllEmailDomainsDescription[] =
    "When enabled, credit card upload is offered without regard to the user's "
    "logged-in account's domain.";

const char kAutofillUseMobileLabelDisambiguationName[] =
    "Autofill Uses Mobile Label Disambiguation";
const char kAutofillUseMobileLabelDisambiguationDescription[] =
    "When enabled, Autofill suggestions' labels are displayed using a "
    "mobile-friendly format.";

const char kAutofillUseRendererIDsName[] =
    "Autofill logic uses unqiue renderer IDs";
const char kAutofillUseRendererIDsDescription[] =
    "When enabled, Autofill logic uses unique numeric renderer IDs instead "
    "of string form and field identifiers in form filling logic.";

const char kBreakpadNoDelayInitialUploadName[] =
    "Remove delay on initial crash upload";
const char kBreakpadNoDelayInitialUploadDescription[] =
    "When enabled, the initial crash uploading will not be delayed. When "
    "disabled, initial upload is delayed until deferred initialization. This "
    "does not affect recovery mode.";

const char kBubbleRichIPHName[] = "Bubble rich IPH";
const char kBubbleRichIPHDescription[] =
    "When enabled, displays a rich description (ex: title, image, etc..) of "
    "the feature presented in the bubble. Also enables password suggestion "
    "highlight IPH. When enabled with no option, uses the default bubble "
    "style.";

extern const char kCalendarExperienceKitName[] = "Experience Kit Calendar";
extern const char kCalendarExperienceKitDescription[] =
    "When enabled, long pressing on dates will trigger Experience Kit Calendar "
    "event handling.";

extern const char kAppleCalendarExperienceKitName[] =
    "Experience Kit Apple Calendar";
extern const char kAppleCalendarExperienceKitDescription[] =
    "When enabled, long pressing on dates will trigger Experience Kit Apple "
    "Calendar event handling.";

extern const char kEnableExpKitCalendarTextClassifierName[] =
    "Text Classifier in Experience Kit Calendar";
extern const char kEnableExpKitCalendarTextClassifierDescription[] =
    "When enabled, Experience Kit Calendar will use Text Classifier library in "
    "entity detection where possible.";

extern const char kEnableExpKitTextClassifierName[] =
    "Text Classifier in Experience Kit";
extern const char kEnableExpKitTextClassifierDescription[] =
    "When enabled, Experience Kit will use Text Classifier library in "
    "entity detection where possible.";

extern const char kMapsExperienceKitName[] = "Experience Kit Maps";
extern const char kMapsExperienceKitDescription[] =
    "When enabled, long pressing on an address will trigger Experience Kit Maps"
    "location and directions handling. Requires "
    "#enable-long-press-surrounding-text to be enabled.";

extern const char kLongPressSurroundingTextName[] =
    "Enable Long Press Surrounding Text";
extern const char kLongPressSurroundingTextDescription[] =
    "When enabled, long pressing a text will analyze larger part of the text.";

const char kContentSuggestionsUIModuleRefreshName[] =
    "Content Suggestions UI Module Refresh";
const char kContentSuggestionsUIModuleRefreshDescription[] =
    "When enabled, the Content Suggestions will be redesigned to be contained "
    "into distinct modules.";

const char kCrashpadIOSName[] = "Use Crashpad for crash collection.";
const char kCrashpadIOSDescription[] =
    "When enabled use Crashpad to generate crash reports crash collection. "
    "When disabled use Breakpad. This flag takes two restarts to take effect";

const char kCredentialProviderExtensionPromoName[] =
    "Enable the Credential Provider Extension promo.";
const char kCredentialProviderExtensionPromoDescription[] =
    "When enabled, Credential Provider Extension promo will be "
    "presented to eligible users.";

const char kDefaultBrowserFullscreenPromoExperimentName[] =
    "Default Browser Fullscreen modal experiment";
const char kDefaultBrowserFullscreenPromoExperimentDescription[] =
    "When enabled, will show a modified default browser fullscreen modal promo "
    "UI.";

const char kDefaultBrowserIntentsShowSettingsName[] =
    "Default Browser Intents show settings";
const char kDefaultBrowserIntentsShowSettingsDescription[] =
    "When enabled, external apps can trigger the settings screen showing "
    "default browser tutorial.";

const char kDetectMainThreadFreezeName[] = "Detect freeze in the main thread.";
const char kDetectMainThreadFreezeDescription[] =
    "A crash report will be uploaded if the main thread is frozen more than "
    "the time specified by this flag.";

const char kEnableDiscoverFeedTopSyncPromoName[] =
    "Enable the sync promo on top of the feed.";
const char kEnableDiscoverFeedTopSyncPromoDescription[] =
    "When enabled, a sync promotion will be presented to eligible users on top "
    "of the feed cards.";

const char kDmTokenDeletionName[] = "DMToken deletion";
const char kDmTokenDeletionDescription[] =
    "Delete the corresponding DMToken when a managed browser is deleted in "
    "Chrome Browser Cloud Management.";

const char kEditPasswordsInSettingsName[] = "Edit passwords in settings";
const char kEditPasswordsInSettingsDescription[] =
    "Enables password editing in settings.";

const char kEnableAutofillAddressSavePromptAddressVerificationName[] =
    "Autofill Address Save Prompts Address Verification";
const char kEnableAutofillAddressSavePromptAddressVerificationDescription[] =
    "Enable the address verification support in Autofill address save prompts.";

const char kEnableAutofillAddressSavePromptName[] =
    "Autofill Address Save Prompts";
const char kEnableAutofillAddressSavePromptDescription[] =
    "Enable the Autofill address save prompts.";

const char kEnableCBDSignOutName[] = "Enable Clear Browsing Data Sign-out";
const char kEnableCBDSignOutDescription[] =
    "Offer signed-in user to sign-out from Clear Browsing Data settings.";

const char kEnableCheckVisibilityOnAttentionLogStartName[] =
    "Enable Check Feed Visibility On Attention Log Start";
const char kEnableCheckVisibilityOnAttentionLogStartDescription[] =
    "Enable checking feed visibility on attention log start.";

const char kEnableCompromisedPasswordsMutingName[] =
    "Enable the muting of compromised passwords in the Password Manager";
const char kEnableCompromisedPasswordsMutingDescription[] =
    "Enable the compromised password alert mutings in Password Manager to be "
    "respected in the app.";

const char kEnableDiscoverFeedDiscoFeedEndpointName[] =
    "Enable discover feed discofeed";
const char kEnableDiscoverFeedDiscoFeedEndpointDescription[] =
    "Enable using the discofeed endpoint for the discover feed.";

const char kEnableDiscoverFeedGhostCardsName[] =
    "Enable discover feed ghost cards";
const char kEnableDiscoverFeedGhostCardsDescription[] =
    "Show ghost cards when refreshing the discover feed.";

const char kEnableFREDefaultBrowserPromoScreenName[] =
    "Enable FRE default browser screen";
const char kEnableFREDefaultBrowserPromoScreenDescription[] =
    "Display the FRE default browser screen and other default browser promo "
    "depending on experiment.";

const char kEnableFeedAblationName[] = "Enables Feed Ablation";
const char kEnableFeedAblationDescription[] =
    "If Enabled the Feed will be removed from the NTP";

const char kEnableFullscreenAPIName[] = "Enable Fullscreen API";
const char kEnableFullscreenAPIDescription[] =
    "Enable the Fullscreen API for web content (iOS 16.0+).";

const char kPasswordsGroupingName[] =
    "Enable password grouping for the Password Manager";
const char kPasswordsGroupingDescription[] =
    "Group passwords into the same affiliated group in the Password Manager "
    "for the Saved Passwords section";

const char kEnableOpenInDownloadName[] = "Enable Open In download";
const char kEnableOpenInDownloadDescription[] =
    "Enable new download for Open In menu (iOS 14.5+).";

const char kEnablePasswordsAccountStorageName[] =
    "Enable the account data storage for passwords";
const char kEnablePasswordsAccountStorageDescription[] =
    "Enables storing passwords in a second, Gaia-account-scoped storage for "
    "signed-in but not syncing users";

const char kEnablePinnedTabsName[] = "Enable Pinned Tabs";
const char kEnablePinnedTabsDescription[] = "Allows users to pin tabs.";

const char kEnableRefineDataSourceReloadReportingName[] =
    "Enable Refine Data Source Reload Reporting";
const char kEnableRefineDataSourceReloadReportingDescription[] =
    "Enable refining data source reload reporting when having a very short "
    "attention log";

const char kEnableUnicornAccountSupportName[] =
    "Enable Unicorn account support";
const char kEnableUnicornAccountSupportDescription[] =
    "Allows users to sign-in with their Unicorn account.";

const char kEnableWebPageAnnotationsName[] = "Enable Web Page Intent Detection";
const char kEnableWebPageAnnotationsDescription[] =
    "Prototype to detect and highlight data with possible intent in a web "
    "page.";

const char kEnableSuggestionsScrollingOnIPadName[] =
    "Enable omnibox suggestions scrolling on iPad";
const char kEnableSuggestionsScrollingOnIPadDescription[] =
    "Enable omnibox suggestions scrolling on iPad and disable suggestions "
    "hiding on keyboard dismissal.";

const char kEnableUserPolicyName[] = "Enable user policies";
const char kEnableUserPolicyDescription[] =
    "Enable the fetch and application of user policies when synced with a "
    "managed account";

const char kEnableWebChannelsName[] = "Enable WebFeed";
const char kEnableWebChannelsDescription[] =
    "Enable folowing content from web and display Following feed on NTP based "
    "on sites that users followed.";

const char kEnhancedProtectionName[] = "Enable Enhanced Safe Browsing";
const char kEnhancedProtectionDescription[] =
    "Allows users to opt-in to Enhanced Safe Browsing";

const char kEnhancedProtectionPhase2Name[] =
    "Enable Enhanced Safe Browsing Phase 2";
const char kEnhancedProtectionPhase2Description[] =
    "Enable additional improvements related to Enhanced Safe Browsing";

const char kTailoredSecurityIntegrationName[] =
    "Enable Tailored Security Integration";
const char kTailoredSecurityIntegrationDescription[] =
    "Enable integration between account level enhanced safe browsing and "
    "chrome enhanced safe browsing";

const char kExpandedTabStripName[] = "Enable expanded tabstrip";
const char kExpandedTabStripDescription[] =
    "Enables the new expanded tabstrip. Activated by swiping down the tabstrip"
    " or the toolbar";

const char kFeedBackgroundRefreshName[] = "Enable feed background refresh";
const char kFeedBackgroundRefreshDescription[] =
    "Schedules a feed background refresh after some minimum period of time has "
    "passed after the last refresh.";

const char kFillingAcrossAffiliatedWebsitesName[] =
    "Fill passwords across affiliated websites.";
const char kFillingAcrossAffiliatedWebsitesDescription[] =
    "Enables filling password on a website when there is saved "
    "password on affiliated website.";

const char kFollowingFeedDefaultSortTypeName[] =
    "Following feed default sort type.";
const char kFollowingFeedDefaultSortTypeDescription[] =
    "Sets the default sort type for Following feed content.";

const char kForceStartupSigninPromoName[] = "Display the startup sign-in promo";
const char kForceStartupSigninPromoDescription[] =
    "When enabled, the startup sign-in promo is always displayed when starting "
    "Chrome.";

const char kFullscreenPromosManagerName[] = "Fullscreen Promos Manager";
const char kFullscreenPromosManagerDescription[] =
    "When enabled, the display of fullscreen promos will be coordinated by a "
    "central manager living at the application level.";

const char kFullscreenPromosManagerSkipInternalLimitsName[] =
    "Fullscreen Promos Manager (Skip internal Impression Limits)";
const char kFullscreenPromosManagerSkipInternalLimitsDescription[] =
    "When enabled, the internal Impression Limits of the Promos Manager will "
    "be ignored; this is useful for local development.";

const char kFullscreenSmoothScrollingName[] = "Fullscreen Smooth Scrolling";
const char kFullscreenSmoothScrollingDescription[] =
    "When enabled, the web view's insets are updated for scoll events. If "
    "disabled, the the web view's frame are updated.";

const char kHttpsOnlyModeName[] = "HTTPS-Only Mode Setting";
const char kHttpsOnlyModeDescription[] = "Enables the HTTPS-Only Mode setting";

const char kIncognitoNtpRevampName[] = "Revamped Incognito New Tab Page";
const char kIncognitoNtpRevampDescription[] =
    "When enabled, Incognito new tab page will have an updated UI.";

const char kInterestFeedV2ClickAndViewActionsConditionalUploadName[] =
    "New Content Suggestions taps/views conditional upload";
const char kInterestFeedV2ClickAndViewActionsConditionalUploadDescription[] =
    "Only enable the upload of taps/views after satisfying conditions (e.g., "
    "user views X cards)";

const char kInProductHelpDemoModeName[] = "In-Product Help Demo Mode";
const char kInProductHelpDemoModeDescription[] =
    "When enabled, in-product help promotions occur exactly once per cold "
    "start. Enabled causes all in-product help promotions to occur. Enabling "
    "an individual promotion causes that promotion but no other promotions to "
    "occur.";

const char kIOS3PIntentsInIncognitoName[] = "Third-party intents in Incognito";
const char kIOS3PIntentsInIncognitoDescription[] =
    "When enabled, an additional setting lets the user open links from other "
    "apps in Incognito.";

const char kIOSEnablePasswordManagerBrandingUpdateName[] =
    "Enable new Google Password Manager branding";
const char kIOSEnablePasswordManagerBrandingUpdateDescription[] =
    "Updates icons, strings, and views for Google Password Manager.";

const char kIOSNewPostRestoreExperienceName[] = "New Post Restore Experience";
const char kIOSNewPostRestoreExperienceDescription[] =
    "When enabled, a prompt will be presented after a device restore to "
    "allow the user to sign in again.";

const char kIOSPasswordUISplitName[] = "Password Manager UI Split";
const char kIOSPasswordUISplitDescription[] =
    "Splits Password Settings and "
    "Password Manager into two separate UIs.";

const char kIOSPasswordManagerCrossOriginIframeSupportName[] =
    "IOS Password Manager Cross-Origin Iframe Support";
const char kIOSPasswordManagerCrossOriginIframeSupportDescription[] =
    "Enables password saving and filling in cross-origin iframes on IOS.";

const char kIOSPopularSitesImprovedSuggestionsName[] =
    "Most Visited Tiles (Improved Default Suggestions)";
const char kIOSPopularSitesImprovedSuggestionsDescription[] =
    "Enables improved default suggestions for the most visited tiles, by using "
    "only Chrome iOS usage data to generate its suggestions.";

const char kIOSSharedHighlightingColorChangeName[] =
    "IOS Shared Highlighting color change";
const char kIOSSharedHighlightingColorChangeDescription[] =
    "Changes the Shared Highlighting color of the text fragment"
    "away from the default yellow in iOS. Works with #scroll-to-text-ios flag.";

const char kIOSSharedHighlightingAmpName[] = "Shared Highlighting on AMP pages";
const char kIOSSharedHighlightingAmpDescription[] =
    "Enables the Create Link option on AMP pages.";

const char kIOSSharedHighlightingV2Name[] = "Text Fragments UI improvements";
const char kIOSSharedHighlightingV2Description[] =
    "Enables improvements to text fragments UI, including a menu for removing "
    "or resharing a highlight.";

const char kKeyboardShortcutsMenuName[] = "Keyboard Shortcuts Menu";
const char kKeyboardShortcutsMenuDescription[] =
    "Enables the new keyboard shortcuts menu.";

const char kLockBottomToolbarName[] = "Lock bottom toolbar";
const char kLockBottomToolbarDescription[] =
    "When enabled, the bottom toolbar will not get collapsed when scrolling "
    "into fullscreen mode.";

const char kLogBreadcrumbsName[] = "Log Breadcrumb Events";
const char kLogBreadcrumbsDescription[] =
    "When enabled, breadcrumb events will be logged.";

const char kMediaPermissionsControlName[] =
    "Camera and Microphone Access Permissions Control";
const char kMediaPermissionsControlDescription[] =
    "Enables user control for camera and/or microphone access for a specific "
    "site through site settings during its lifespan.";

const char kMetrickitNonCrashReportName[] = "Metrickit non-crash reports";
const char kMetrickitNonCrashReportDescription[] =
    "Enables sending Metrickit reports for non crash type (hang, "
    "cpu-exception, diskwrite-exception)";

const char kModernTabStripName[] = "Modern TabStrip";
const char kModernTabStripDescription[] =
    "When enabled, the newly implemented tabstrip can be tested.";

const char kMostVisitedTilesName[] = "Most Visited Tiles";
const char kMostVisitedTilesDescription[] =
    "Enables the most visited tiles in the omnibox. Shows most visited "
    "websites in a tile format when the user focuses the omnibox on a search "
    "result page (SRP) or on web.";

const char kNewMobileIdentityConsistencyFREName[] = "New MICE FRE";
const char kNewMobileIdentityConsistencyFREDescription[] =
    "New Mobile Identity Consistency FRE";

const char kNewOverflowMenuName[] = "New Overflow Menu";
const char kNewOverflowMenuDescription[] = "Enables the new overflow menu";

const char kNewOverflowMenuAlternateIPHName[] =
    "New Overflow Menu Alternative IPH";
const char kNewOverflowMenuAlternateIPHDescription[] =
    "Uses the alternative IPH flow for the new overflow menu";

const char kNTPViewHierarchyRepairName[] = "NTP View Hierarchy Repair";
const char kNTPViewHierarchyRepairDescription[] =
    "Checks if NTP view hierarchy is broken and fixes it if necessary.";

const char kOmniboxCarouselDynamicSpacingName[] =
    "Omnibox Carousel dynamic spacing";
const char kOmniboxCarouselDynamicSpacingDescription[] =
    "Enables dynamic spacing in omnibox carousel, this increases the spacing "
    "between the tiles to have half of a tile visible, to indicate a "
    "scrollable list";

const char kOmniboxFuzzyUrlSuggestionsName[] = "Omnibox Fuzzy URL Suggestions";
const char kOmniboxFuzzyUrlSuggestionsDescription[] =
    "Enables URL suggestions for inputs that may contain typos.";

const char kOmniboxHttpsUpgradesName[] = "Omnibox HTTPS upgrades";
const char kOmniboxHttpsUpgradesDescription[] =
    "Enables HTTPS upgrades for omnibox navigations typed without a scheme";

const char kOmniboxKeyboardPasteButtonName[] = "Omnibox keyboard paste button";
const char kOmniboxKeyboardPasteButtonDescription[] =
    "Enables paste button in the omnibox's keyboard accessory. Only available "
    "from iOS 16 onward.";

const char kOmniboxUIMaxAutocompleteMatchesName[] =
    "Omnibox UI Max Autocomplete Matches";
const char kOmniboxUIMaxAutocompleteMatchesDescription[] =
    "Changes the maximum number of autocomplete matches displayed in the "
    "Omnibox UI.";

const char kOmniboxMaxZPSMatchesName[] = "Omnibox Max ZPS Matches";
const char kOmniboxMaxZPSMatchesDescription[] =
    "Changes the maximum number of autocomplete matches displayed in the "
    "zero-prefix state in the omnibox (e.g. on NTP when tapped on OB).";

const char kOmniboxOnDeviceHeadSuggestionsIncognitoName[] =
    "Omnibox on device head suggestions (incognito only)";
const char kOmniboxOnDeviceHeadSuggestionsIncognitoDescription[] =
    "Shows Google head non personalized search suggestions provided by a "
    "compact on device model for incognito";

const char kOmniboxOnDeviceHeadSuggestionsNonIncognitoName[] =
    "Omnibox on device head suggestions (non-incognito only)";
const char kOmniboxOnDeviceHeadSuggestionsNonIncognitoDescription[] =
    "Shows Google head non personalized search suggestions provided by a "
    "compact on device model for non-incognito";

const char kOmniboxOnFocusSuggestionsName[] = "Omnibox on-focus suggestions";
const char kOmniboxOnFocusSuggestionsDescription[] =
    "Configures Omnibox on-focus suggestions - suggestions displayed on-focus "
    "before the user has typed any input. This provides overrides for the "
    "default suggestion locations.";

const char kOmniboxMaxURLMatchesName[] = "Omnibox Max URL matches";
const char kOmniboxMaxURLMatchesDescription[] =
    "Limit the number of URL suggestions in the omnibox. The omnibox will "
    "still display more than MaxURLMatches if there are no non-URL suggestions "
    "to replace them.";

const char kOmniboxNewImplementationName[] =
    "Use experimental omnibox textfield";
const char kOmniboxNewImplementationDescription[] =
    "Uses a textfield implementation that doesn't use UILabels internally";

const char kOmniboxFocusTriggersContextualWebZeroSuggestName[] =
    "Omnibox on-focus suggestions for the contextual Web";
const char kOmniboxFocusTriggersContextualWebZeroSuggestDescription[] =
    "Enables on-focus suggestions on the Open Web, that are contextual to the "
    "current URL. Will only work if user is signed-in and syncing, or is "
    "otherwise eligible to send the current page URL to the suggest server.";

const char kOmniboxFocusTriggersSRPZeroSuggestName[] =
    "Allow Omnibox contextual web on-focus suggestions on the SRP";
const char kOmniboxFocusTriggersSRPZeroSuggestDescription[] =
    "Enables on-focus suggestions on the Search Results page. Requires "
    "on-focus suggestions for the contextual web to be enabled. Will only work "
    "if user is signed-in and syncing.";

const char kOmniboxPasteButtonName[] = "Omnibox paste to search button";
const char kOmniboxPasteButtonDescription[] =
    "Add a paste button when showing clipboard suggestions in the omnibox. iOS "
    "16 and above.";

const char kOmniboxLocalHistoryZeroSuggestBeyondNTPName[] =
    "Allow local history zero-prefix suggestions beyond NTP";
const char kOmniboxLocalHistoryZeroSuggestBeyondNTPDescription[] =
    "Enables local history zero-prefix suggestions in every context in which "
    "the remote zero-prefix suggestions are enabled.";

const char kOmniboxZeroSuggestPrefetchingName[] =
    "Omnibox Zero Prefix Suggestion Prefetching on NTP";
const char kOmniboxZeroSuggestPrefetchingDescription[] =
    "Enables prefetching of the zero prefix suggestions for eligible users "
    "on the New Tab page.";

const char kOmniboxZeroSuggestPrefetchingOnSRPName[] =
    "Omnibox Zero Prefix Suggestion Prefetching on SRP";
const char kOmniboxZeroSuggestPrefetchingOnSRPDescription[] =
    "Enables prefetching of the zero prefix suggestions for eligible users "
    "on the Search Results page.";

const char kOmniboxZeroSuggestPrefetchingOnWebName[] =
    "Omnibox Zero Prefix Suggestion Prefetching on the Web";
const char kOmniboxZeroSuggestPrefetchingOnWebDescription[] =
    "Enables prefetching of the zero prefix suggestions for eligible users "
    "on the Web (i.e. non-NTP and non-SRP URLs).";

const char kOmniboxZeroSuggestInMemoryCachingName[] =
    "Omnibox Zero Prefix Suggestion in-memory caching";
const char kOmniboxZeroSuggestInMemoryCachingDescription[] =
    "Enables in-memory caching of zero prefix suggestions.";

const char kOmniboxOnDeviceTailSuggestionsName[] =
    "Omnibox on device tail suggestions";
const char kOmniboxOnDeviceTailSuggestionsDescription[] =
    "Google tail non personalized search suggestions provided by a compact on "
    "device model.";

const char kIOSOmniboxUpdatedPopupUIName[] = "Popup refresh";
const char kIOSOmniboxUpdatedPopupUIDescription[] =
    "Enable the new Popup implementation with Actions";

const char kOptimizationGuideDebugLogsName[] =
    "Enable optimization guide debug logs";
const char kOptimizationGuideDebugLogsDescription[] =
    "Enables the optimization guide to log and save debug messages that can be "
    "shown in the internals page.";

const char kOptimizationGuideModelDownloadingName[] =
    "Allow optimization guide model downloads";
const char kOptimizationGuideModelDownloadingDescription[] =
    "Enables the optimization guide to download prediction models.";

const char kOptimizationTargetPredictionDescription[] =
    "Enables prediction of optimization targets";
const char kOptimizationTargetPredictionName[] =
    "Enables usage of optimization guide TFLite models.";

const char kPasswordReuseDetectionName[] =
    "PhishGuard password reuse detection";
const char kPasswordReuseDetectionDescription[] =
    "Displays warning when user types or pastes a saved password into a "
    "phishing website.";

const char kRecordSnapshotSizeName[] =
    "Record the size of image and PDF snapshots in UMA histograms";
const char kRecordSnapshotSizeDescription[] =
    "When enabled, the app will record UMA histograms for image and PDF "
    "snapshots. PDF snaphot will be taken just for the purpose of the "
    "histogram recording.";

const char kRemoveCrashInfobarName[] = "Remove Crash Infobars";
const char kRemoveCrashInfobarDescription[] =
    "When enabled, always auto restore tabs rather than showing a crash "
    "infobar";

const char kRemoveExcessNTPsExperimentName[] = "Remove extra New Tab Pages";
const char kRemoveExcessNTPsExperimentDescription[] =
    "When enabled, extra tabs with the New Tab Page open and no navigation "
    "history will be removed.";

const char kRestoreSessionFromCacheName[] =
    "Use native WKWebView sesion restoration (iOS15 only).";
const char kRestoreSessionFromCacheDescription[] =
    "Enable instant session restoration for faster web session restoration "
    "(iOS15 only).";

const char kSafeBrowsingAvailableName[] = "Make Safe Browsing available";
const char kSafeBrowsingAvailableDescription[] =
    "When enabled, navigation URLs are compared to Safe Browsing blocklists, "
    "subject to an opt-out preference.";

const char kSafeBrowsingRealTimeLookupName[] = "Enable real-time Safe Browsing";
const char kSafeBrowsingRealTimeLookupDescription[] =
    "When enabled, navigation URLs are checked using real-time queries to Safe "
    "Browsing servers, subject to an opt-in preference.";

const char kSaveSessionTabsToSeparateFilesName[] =
    "Enable save tabs to separate files";
const char kSaveSessionTabsToSeparateFilesDescription[] =
    "When enabled, each Tab is saved in a separate file.";

const char kScreenTimeIntegrationName[] = "Enables ScreenTime Integration";
const char kScreenTimeIntegrationDescription[] =
    "Enables integration with ScreenTime in iOS 14.0 and above.";

const char kSendTabToSelfSigninPromoName[] = "Send tab to self sign-in promo";
const char kSendTabToSelfSigninPromoDescription[] =
    "Enables a sign-in promo if the user attempts to share a tab while being "
    "signed out";

const char kSendUmaOverAnyNetwork[] =
    "Send UMA data over any network available.";
const char kSendUmaOverAnyNetworkDescription[] =
    "When enabled, will send UMA data over either WiFi or cellular by default.";

const char kSharedHighlightingIOSName[] = "Enable Shared Highlighting features";
const char kSharedHighlightingIOSDescription[] =
    "Adds a Link to Text option in the Edit Menu which generates URLs with a "
    "text fragment.";

const char kShowAutofillTypePredictionsName[] = "Show Autofill predictions";
const char kShowAutofillTypePredictionsDescription[] =
    "Annotates web forms with Autofill field type predictions as placeholder "
    "text.";

const char kSmartSortingNewOverflowMenuName[] =
    "Smart Sorting the new Overflow Menu";
const char kSmartSortingNewOverflowMenuDescription[] =
    "Enables smart sorting the new overflow menu carousel by frecency.";

const char kNewOverflowMenuShareChromeActionName[] =
    "Share Chrome App action in the new overflow menu";
const char kNewOverflowMenuShareChromeActionDescription[] =
    "Enables the Share Chrome App action in the new overflow menu.";

const char kSyncSandboxName[] = "Use Chrome Sync sandbox";
const char kSyncSandboxDescription[] =
    "Connects to the testing server for Chrome Sync.";

const char kSynthesizedRestoreSessionName[] =
    "Use a synthesized native WKWebView sesion restoration (iOS15 only).";
const char kSynthesizedRestoreSessionDescription[] =
    "Enable instant session restoration by synthesizing WKWebView session "
    "restoration data (iOS15 only).";

const char kSyncEnableHistoryDataTypeName[] = "Enable History sync data type";
const char kSyncEnableHistoryDataTypeDescription[] =
    "Enables the History sync data type instead of TypedURLs";

const char kSyncTrustedVaultPassphrasePromoName[] =
    "Enable promos for sync trusted vault passphrase.";
const char kSyncTrustedVaultPassphrasePromoDescription[] =
    "Enables promos for an experimental sync passphrase type, referred to as "
    "trusted vault.";

const char kSyncTrustedVaultPassphraseRecoveryName[] =
    "Enable sync trusted vault passphrase with improved recovery.";
const char kSyncTrustedVaultPassphraseRecoveryDescription[] =
    "Enables support for an experimental sync passphrase type, referred to as "
    "trusted vault, including logic and APIs for improved account recovery "
    "flows.";

const char kSyncInvalidationsName[] = "Use Sync standalone invalidations";
const char kSyncInvalidationsDescription[] =
    "If enabled, Sync will use standalone invalidations instead of topic based "
    "invalidations (Wallet and Offer data types are enabled by a dedicated "
    "flag).";

const char kSyncInvalidationsWalletAndOfferName[] =
    "Use Sync standalone invalidations for Wallet and Offer";
const char kSyncInvalidationsWalletAndOfferDescription[] =
    "If enabled, Sync will use standalone invalidations for Wallet and Offer "
    "data types. Takes effect only when Sync standalone invalidations are "
    "enabled.";

const char kStartSurfaceName[] = "Start Surface";
const char kStartSurfaceDescription[] =
    "Enable showing the Start Surface when launching Chrome via clicking the "
    "icon or the app switcher.";

const char kDownloadServiceForegroundSessionName[] =
    "Download service foreground download";
const char kDownloadServiceForegroundSessionDescription[] =
    "Enable download service to download in app foreground only";

const char kTFLiteLanguageDetectionName[] = "TFLite-based Language Detection";
const char kTFLiteLanguageDetectionDescription[] =
    "Uses TFLite for language detection in place of CLD3";

const char kTFLiteLanguageDetectionIgnoreName[] =
    "Ignore TFLite-based Language Detection";
const char kTFLiteLanguageDetectionIgnoreDescription[] =
    "Computes the TFLite language detection but ignore the result and uses the "
    "CLD3 detection instead.";

const char kToolbarContainerName[] = "Use Toolbar Containers";
const char kToolbarContainerDescription[] =
    "When enabled, the toolbars and their fullscreen animations will be "
    "managed by the toolbar container coordinator rather than BVC.";

extern const char kTrendingQueriesModuleName[] = "Show Trending Queries module";
extern const char kTrendingQueriesModuleDescription[] =
    "When enabled, the trending queries module will be shown in the NTP";

extern const char kTruncateTableViewCellTitleName[] =
    "Truncate title of table view cell";
extern const char kTruncateTableViewCellTitleDescription[] =
    "When enabled, title of table view cell is truncated and not wrapped";

const char kUpdateHistoryEntryPointsInIncognitoName[] =
    "Update history entry points in Incognito.";
const char kUpdateHistoryEntryPointsInIncognitoDescription[] =
    "When enabled, the entry points to history UI from Incognito mode will be "
    "removed.";

const char kUseLensToSearchForImageName[] =
    "Use Google Lens to Search for images";
const char kUseLensToSearchForImageDescription[] =
    "When enabled, use Lens to search for images from the long press context "
    "menu when Google is the selected search engine.";

const char kEnableLensInHomeScreenWidgetName[] =
    "Enable Google Lens in the Home Screen Widget";
const char kEnableLensInHomeScreenWidgetDescription[] =
    "When enabled, use Lens to search for images from your device camera "
    "menu when Google is the selected search engine, accessible from the"
    "home screen widget.";

const char kEnableLensInKeyboardName[] =
    "Enable Google Lens in the Omnibox Keyboard";
const char kEnableLensInKeyboardDescription[] =
    "When enabled, use Lens to search for images from your device camera "
    "menu when Google is the selected search engine, accessible from the"
    "omnibox keyboard.";

const char kEnableLensInNTPName[] = "Enable Google Lens in the NTP";
const char kEnableLensInNTPDescription[] =
    "When enabled, use Lens to search for images from your device camera "
    "menu when Google is the selected search engine, accessible from the"
    "new tab page.";

const char kEnableLensInOmniboxCopiedImageName[] =
    "Enable Google Lens in the Omnibox for Copied Images";
const char kEnableLensInOmniboxCopiedImageDescription[] =
    "When enabled, use Lens to search images from your device clipboard "
    "when Google is the selected search engine, accessible from the omnibox or "
    "popup menu.";

const char kTabGridRecencySortName[] = "Change TabGrid sorting";
const char kTabGridRecencySortDescription[] =
    "When enabled, the tabs in the Tab Grid are sorted differently.";

const char kUseLoadSimulatedRequestForOfflinePageName[] =
    "Use loadSimulatedRequest:responseHTMLString: when displaying offline "
    "pages";
const char kUseLoadSimulatedRequestForOfflinePageDescription[] =
    "When enabled, the offline pages uses the iOS 15 "
    "loadSimulatedRequest:responseHTMLString: API";

const char kUseSFSymbolsName[] = "Replace Image by SFSymbols";
const char kUseSFSymbolsDescription[] =
    "When enabled, images are replaced by SFSymbols";

const char kUseSFSymbolsInOmniboxName[] =
    "Replace Image by SFSymbols in Omnibox";
const char kUseSFSymbolsInOmniboxDescription[] =
    "When enabled, images are replaced by SFSymbols in the omnibox";

const char kWaitThresholdMillisecondsForCapabilitiesApiName[] =
    "Maximum wait time (in seconds) for a response from the Account "
    "Capabilities API";
const char kWaitThresholdMillisecondsForCapabilitiesApiDescription[] =
    "Used for testing purposes to test waiting thresholds in dev.";

const char kWalletServiceUseSandboxName[] = "Use Google Payments sandbox";
const char kWalletServiceUseSandboxDescription[] =
    "Uses the sandbox service for Google Payments API calls.";

const char kWebPageDefaultZoomFromDynamicTypeName[] =
    "Use dynamic type size for default text zoom level";
const char kWebPageDefaultZoomFromDynamicTypeDescription[] =
    "When enabled, the default text zoom level for a website comes from the "
    "current dynamic type setting.";

const char kWebPageAlternativeTextZoomName[] =
    "Use different method for zooming web pages";
const char kWebPageAlternativeTextZoomDescription[] =
    "When enabled, switches the method used to zoom web pages.";

const char kWebPageTextZoomIPadName[] = "Enable text zoom on iPad";
const char kWebPageTextZoomIPadDescription[] =
    "When enabled, text zoom works again on iPad";

const char kWhatsNewIOSName[] = "Enable What's New.";
const char kWhatsNewIOSDescription[] =
    "When enabled, What's New will display new features and chrome tips.";

// Please insert your name/description above in alphabetical order.

}  // namespace flag_descriptions


text:
from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_param_Pl011', [dirname(__file__)])
        except ImportError:
            import _param_Pl011
            return _param_Pl011
        if fp is not None:
            try:
                _mod = imp.load_module('_param_Pl011', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _param_Pl011 = swig_import_helper()
    del swig_import_helper
else:
    import _param_Pl011
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0

def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr

import param_Gic
import param_Platform
import param_IntrControl
import param_System
import enum_MemoryMode
import AbstractMemory_vector
import param_AbstractMemory
import range
import param_MemObject
import param_SimObject
import param_PioDevice
import param_Uart
import param_Terminal
import param_BasicPioDevice
class Pl011(param_Uart.Uart):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
Pl011_swigregister = _param_Pl011.Pl011_swigregister
Pl011_swigregister(Pl011)

class Pl011Params(param_Uart.UartParams):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def create(self): return _param_Pl011.Pl011Params_create(self)
    int_num = _swig_property(_param_Pl011.Pl011Params_int_num_get, _param_Pl011.Pl011Params_int_num_set)
    gic = _swig_property(_param_Pl011.Pl011Params_gic_get, _param_Pl011.Pl011Params_gic_set)
    end_on_eot = _swig_property(_param_Pl011.Pl011Params_end_on_eot_get, _param_Pl011.Pl011Params_end_on_eot_set)
    int_delay = _swig_property(_param_Pl011.Pl011Params_int_delay_get, _param_Pl011.Pl011Params_int_delay_set)
    def __init__(self):
        this = _param_Pl011.new_Pl011Params()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _param_Pl011.delete_Pl011Params
    __del__ = lambda self : None;
Pl011Params_swigregister = _param_Pl011.Pl011Params_swigregister
Pl011Params_swigregister(Pl011Params)

redpajama_set_name: RedPajamaGithub


text:
var fs = require('fs');
var osr = require('./OfflineSearchResult');
var OfflineSearcher = (function () {
    function OfflineSearcher(project, options) {
        var _this = this;
        this.project = project;
        this.options = options;
        this.propertyNames = [];
        this.filesToProcess = 0;
        this.result = new osr.OfflineSearchResult(project, options);
        this.layers = this.result.layers;
        this.stopWords = this.result.options.stopWords;
        this.keywordIndex = this.result.keywordIndex;
        this.result.options.propertyNames.forEach(function (pt) {
            _this.propertyNames.push(pt);
        });
    }
    Object.defineProperty(OfflineSearcher.prototype, "savedFilename", {
        get: function () {
            return 'public/' + this.project.url.replace('project.json', 'offline_search_result.json');
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(OfflineSearcher.prototype, "projectFilename", {
        get: function () {
            return 'public/' + this.project.url;
        },
        enumerable: true,
        configurable: true
    });
    OfflineSearcher.prototype.layerFilename = function (baseUrl) {
        return 'public/' + baseUrl;
    };
    OfflineSearcher.prototype.processProject = function () {
        var _this = this;
        fs.readFile(this.projectFilename, 'utf8', function (err, data) {
            if (err) {
                console.log('Error: ' + err);
                return;
            }
            var project = JSON.parse(data);
            if (!project.groups)
                return;
            project.groups.forEach(function (group) {
                if (!group.layers)
                    return;
                group.layers.forEach(function (layer) {
                    var layerType = layer.type.toLowerCase();
                    if (!(layerType === 'geojson'))
                        return;
                    _this.processLayer(layer, group.title || group.languages['nl'].title);
                });
            });
            _this.saveResult();
        });
    };
    OfflineSearcher.prototype.processLayer = function (layer, groupTitle) {
        var _this = this;
        this.filesToProcess++;
        if (layer.title == null)
            layer.title = layer.id;
        var layerIndex = this.layers.length;
        var resultLayer = new osr.Layer(groupTitle, layerIndex, layer.id, layer.title, layer.url, layer.type);
        this.layers.push(resultLayer);
        console.log(layerIndex + '. Processing ' + layer.title + ' (' + groupTitle + ')');
        fs.readFile(this.layerFilename(layer.url), 'utf8', function (err, data) {
            if (err) {
                _this.filesToProcess--;
                console.log(err);
                _this.saveResult();
                return;
            }
            var geojson = JSON.parse(data);
            var featureIndex = 0;
            if (!geojson.features)
                return;
            geojson.features.forEach(function (feature) {
                resultLayer.featureNames.push(_this.getShortenedName(feature));
                if (feature.hasOwnProperty('properties'))
                    _this.processProperties(feature.properties, layerIndex, featureIndex++);
            });
            console.log(layerIndex + '. Processed ' + layer.title);
            _this.filesToProcess--;
            _this.saveResult();
        });
    };
    OfflineSearcher.prototype.getShortenedName = function (feature) {
        var name = feature.properties.hasOwnProperty("Name")
            ? feature.properties["Name"]
            : feature.properties.hasOwnProperty("name")
                ? feature.properties["name"]
                : "Unknown";
        if (name.length > 25)
            name = name.substring(0, 22) + '...';
        return name;
    };
    OfflineSearcher.prototype.processProperties = function (props, layerIndex, featureIndex) {
        var _this = this;
        for (var i = 0; i < this.propertyNames.length; i++) {
            var key = this.propertyNames[i];
            if (!props.hasOwnProperty(key))
                continue;
            var value = props[key];
            if (typeof value === 'string') {
                var words = value.split(' ');
                if (words.length <= 0)
                    continue;
                words.forEach(function (word) {
                    _this.addEntry(word, layerIndex, featureIndex);
                });
            }
            else {
                this.addEntry('' + value, layerIndex, featureIndex);
            }
        }
    };
    OfflineSearcher.prototype.addEntry = function (key, layerIndex, featureIndex) {
        key = key.toLowerCase();
        if (this.stopWords.indexOf(key) >= 0)
            return;
        if (!this.keywordIndex.hasOwnProperty(key)) {
            this.keywordIndex[key] = [];
        }
        else {
            var entries = this.keywordIndex[key];
            for (var i = 0; i < entries.length; i++) {
                var entry = entries[i];
                if (entry.layerIndex === layerIndex && entry.featureIndex === featureIndex)
                    return;
            }
        }
        this.keywordIndex[key].push(new osr.Entry(layerIndex, featureIndex));
    };
    OfflineSearcher.prototype.addFullEntry = function (key, entry) {
        if (!this.keywordIndex.hasOwnProperty(key)) {
            this.keywordIndex[key] = [];
        }
        this.keywordIndex[key].push(new osr.Entry(entry));
    };
    OfflineSearcher.prototype.saveResult = function () {
        if (this.filesToProcess > 0)
            return;
        var file = this.savedFilename;
        fs.writeFile(file, JSON.stringify(this.result, null, 0), function (err) {
            if (err) {
                console.log(err);
            }
            else {
                console.log('JSON saved to ' + file);
            }
        });
    };
    OfflineSearcher.prototype.loadResult = function () {
        var _this = this;
        var file = this.savedFilename;
        fs.readFile(file, 'utf8', function (err, data) {
            if (err) {
                console.log('Error: ' + err);
                return;
            }
            var osr = JSON.parse(data);
            _this.layers = osr.layers;
            _this.options = osr.options;
            _this.propertyNames = [];
            _this.project = osr.project;
            _this.stopWords = osr.options.stopWords;
            osr.options.propertyNames.forEach(function (pt) {
                _this.propertyNames.push(pt.toLowerCase());
            });
            _this.keywordIndex = {};
            for (var key in osr.keywordIndex) {
                osr.keywordIndex[key].forEach(function (entry) {
                    _this.addFullEntry(key, entry);
                });
            }
        });
    };
    return OfflineSearcher;
})();
exports.OfflineSearcher = OfflineSearcher;


text:
package org.h2.expression;

import org.h2.command.dml.Query;
import org.h2.engine.Session;
import org.h2.result.ResultInterface;
import org.h2.table.ColumnResolver;
import org.h2.table.TableFilter;
import org.h2.util.StringUtils;
import org.h2.value.Value;
import org.h2.value.ValueBoolean;

/**
 * An 'exists' condition as in WHERE EXISTS(SELECT ...)
 */
public class ConditionExists extends Condition {

    private final Query query;

    public ConditionExists(Query query) {
        this.query = query;
    }

    @Override
    public Value getValue(Session session) {
        query.setSession(session);
        ResultInterface result = query.query(1);
        session.addTemporaryResult(result);
        boolean r = result.hasNext();
        return ValueBoolean.get(r);
    }

    @Override
    public Expression optimize(Session session) {
        session.optimizeQueryExpression(query);
        return this;
    }

    @Override
    public String getSQL() {
        return "EXISTS(\n" + StringUtils.indent(query.getPlanSQL(), 4, false) + ")";
    }

    @Override
    public void updateAggregate(Session session) {
        // TODO exists: is it allowed that the subquery contains aggregates?
        // probably not
        // select id from test group by id having exists (select * from test2
        // where id=count(test.id))
    }

    @Override
    public void mapColumns(ColumnResolver resolver, int level) {
        query.mapColumns(resolver, level + 1);
    }

    @Override
    public void setEvaluatable(TableFilter tableFilter, boolean b) {
        query.setEvaluatable(tableFilter, b);
    }

    @Override
    public boolean isEverything(ExpressionVisitor visitor) {
        return query.isEverything(visitor);
    }

    @Override
    public int getCost() {
        return query.getCostAsExpression();
    }

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/gradle/gradle.iml" filepath="$PROJECT_DIR$/gradle/gradle.iml" />
      <module fileurl="file://$PROJECT_DIR$/spring-social-quickstart.iml" filepath="$PROJECT_DIR$/spring-social-quickstart.iml" />
    </modules>
  </component>
</project>


text:
    #include "CPUTRenderStateBlockOGL.h"
#else
    #error You must supply a target graphics API (ex: #define CPUT_FOR_DX11), or implement the target API for this file.
#endif

CPUTRenderStateBlock *CPUTRenderStateBlock::mpDefaultRenderStateBlock = NULL;

CPUTRenderStateBlock *CPUTRenderStateBlock::CreateRenderStateBlock( const cString &name, const cString &absolutePathAndFilename )
{
#ifdef CPUT_FOR_DX11
    CPUTRenderStateBlock *pRenderStateBlock = new CPUTRenderStateBlockDX11();
#elif (defined(CPUT_FOR_OGL) || defined (CPUT_FOR_OGLES))
    CPUTRenderStateBlock *pRenderStateBlock = new CPUTRenderStateBlockOGL();
#else
    #error You must supply a target graphics API (ex: #define CPUT_FOR_DX11), or implement the target API for this file.
#endif
    pRenderStateBlock->LoadRenderStateBlock( absolutePathAndFilename );

    // add to library
    CPUTAssetLibrary::GetAssetLibrary()->AddRenderStateBlock( absolutePathAndFilename, _L(""), _L(""), pRenderStateBlock );

    return pRenderStateBlock;
}


text:
<!-- Love property_web_builder? Please consider supporting our collective:
👉  https://opencollective.com/property_web_builder/donate -->


text:
[![Build Status](https://travis-ci.org/acyortjs/acyort.svg?branch=master)](https://travis-ci.org/acyortjs/acyort)
[![codecov](https://codecov.io/gh/acyortjs/acyort/branch/master/graph/badge.svg)](https://codecov.io/gh/acyortjs/acyort)
[![version](https://img.shields.io/npm/v/acyort.svg)](https://www.npmjs.com/package/acyort)
[![license](https://img.shields.io/npm/l/acyort.svg)](https://www.npmjs.com/package/acyort)

A Node.js static website framework.

## Install

```bash
$ npm i acyort -g
```

## Documentation

To check out the docs, visit https://acyort.js.org


text:
/**
* (c) 2017 Pablo Luis García. All rights reserved.
* Released under MIT license. Read LICENSE for more details.
*/

#pragma once

#include <src/graphics/renderable2d.h>

namespace gfx
{

class Sprite : public Renderable2D
{
private:

public:
    Sprite(math::vec2 position, math::vec2 size, TextureArrayInfo textureInfo, GLuint shaderId) : Renderable2D(position, size, textureInfo, shaderId) {}
};

} // namespace gfx


text:
// Copyright (c) 2015 Ratish Philip
//
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// Based on Josh Smith's Article
// http://www.codeproject.com/Articles/70223/Using-a-Service-Locator-to-Work-with-MessageBoxes
//

using System;
using System.Collections.Generic;

namespace NVMSharp.Services
{
    public class ServiceManager
    {
        public static readonly ServiceManager Instance = new ServiceManager();

        private ServiceManager()
        {
            _serviceMap = new Dictionary<Type, object>();
            _serviceMapLock = new object();
        }

        public void AddService<TServiceContract>(TServiceContract implementation)
            where TServiceContract : class
        {
            lock (_serviceMapLock)
            {
                _serviceMap[typeof(TServiceContract)] = implementation;
            }
        }

        public TServiceContract GetService<TServiceContract>()
            where TServiceContract : class
        {
            object service;
            lock (_serviceMapLock)
            {
                _serviceMap.TryGetValue(typeof(TServiceContract), out service);
            }
            return service as TServiceContract;
        }

        readonly Dictionary<Type, object> _serviceMap;
        readonly object _serviceMapLock;
    }
}


text:
package vektah.rust.psi.impl;

import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static vektah.rust.psi.RustTokens.*;
import vektah.rust.psi.*;

public class RustExprCallImpl extends RustExprImpl implements RustExprCall {

  public RustExprCallImpl(ASTNode node) {
    super(node);
  }

  public void accept(@NotNull PsiElementVisitor visitor) {
    if (visitor instanceof RustVisitor) ((RustVisitor)visitor).visitExprCall(this);
    else super.accept(visitor);
  }

  @Override
  @NotNull
  public RustCallParams getCallParams() {
    return findNotNullChildByClass(RustCallParams.class);
  }

  @Override
  @NotNull
  public RustExpr getExpr() {
    return findNotNullChildByClass(RustExpr.class);
  }

}


text:
var config = module.exports;

config["Browser tests"] = {
	rootPath: "../",
	environment: "browser",
	libs: ["node_modules/wheels-class/wheels-class.js"],
	sources: ["wheels-pubsub.js"],
	tests: ["spec/*.spec.js"]
}


text:
package org.yeastrc.proxl.import_xml_to_db.pre_validate_xml;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.LoggerFactory;import org.slf4j.Logger;
import org.yeastrc.proxl.import_xml_to_db.exceptions.ProxlImporterDataException;
import org.yeastrc.proxl_import.api.xml_dto.Peptide;
import org.yeastrc.proxl_import.api.xml_dto.Peptides;
import org.yeastrc.proxl_import.api.xml_dto.ProxlInput;
import org.yeastrc.proxl_import.api.xml_dto.Psm;
import org.yeastrc.proxl_import.api.xml_dto.Psm.PerPeptideAnnotations;
import org.yeastrc.proxl_import.api.xml_dto.Psm.PerPeptideAnnotations.PsmPeptide;
import org.yeastrc.proxl_import.api.xml_dto.Psms;
import org.yeastrc.proxl_import.api.xml_dto.ReportedPeptide;
import org.yeastrc.proxl_import.api.xml_dto.ReportedPeptides;

/**
 *
 * For every psm_peptide, the value of "unique_id" must be on a "peptide" under the same "reported_peptide"
 *
 */
public class ValidatePsmPeptideRecordsUniqueIdOnPeptideRecord {

	private static final Logger log = LoggerFactory.getLogger(  ValidatePsmPeptideRecordsUniqueIdOnPeptideRecord.class );
	private ValidatePsmPeptideRecordsUniqueIdOnPeptideRecord() { }
	public static ValidatePsmPeptideRecordsUniqueIdOnPeptideRecord getInstance() {
		return new ValidatePsmPeptideRecordsUniqueIdOnPeptideRecord();
	}

	/**
	 * For every psm_peptide, the value of "unique_id" must be on a "peptide" under the same "reported_peptide"
	 * @param proxlInput
	 * @throws ProxlImporterDataException for data errors
	 */
	public void validatePsmPeptideRecordsUniqueIdOnPeptideRecord( ProxlInput proxlInput ) throws ProxlImporterDataException {

		ReportedPeptides reportedPeptides = proxlInput.getReportedPeptides();
		if ( reportedPeptides != null ) {
			List<ReportedPeptide> reportedPeptideList =
					reportedPeptides.getReportedPeptide();
			if ( reportedPeptideList != null && ( ! reportedPeptideList.isEmpty() ) ) {
				for ( ReportedPeptide reportedPeptide : reportedPeptideList ) {
					validateSingleReportedPeptide( reportedPeptide );
				}
			}
		}

	}

	/**
	 * @param reportedPeptide
	 * @throws ProxlImporterDataException
	 */
	private void validateSingleReportedPeptide( ReportedPeptide reportedPeptide ) throws ProxlImporterDataException {

		Set<String> peptideUniqueIds = new HashSet<>();

		Peptides peptides = reportedPeptide.getPeptides();
		if ( peptides == null ) {
			String msg = "No Peptides under reported peptide id: " + reportedPeptide.getReportedPeptideString();
			log.error( msg );
			throw new ProxlImporterDataException( msg );
		}
		List<Peptide> peptideList = peptides.getPeptide();
		if ( peptideList == null || peptideList.isEmpty() ) {
			String msg = "No Peptides under reported peptide id: " + reportedPeptide.getReportedPeptideString();
			log.error( msg );
			throw new ProxlImporterDataException( msg );
		}

		// Collect the unique_id on the peptides
		for ( Peptide peptide : peptideList ) {
			String uniqueId = peptide.getUniqueId();
			if ( StringUtils.isNotEmpty( uniqueId ) ) {
				if ( ! peptideUniqueIds.add( uniqueId ) ) {
					String msg = "Peptide unique_id value is duplicate under same reported peptide id. unique_id: " + uniqueId
							+ ", reported peptide id: " + reportedPeptide.getReportedPeptideString();
					log.error( msg );
					throw new ProxlImporterDataException( msg );
				}
			}
		}

		//  Validate the unique_id on the psm_peptide
		Psms psms =	reportedPeptide.getPsms();
		if ( psms != null ) {
			List<Psm> psmList = psms.getPsm();
			if ( psmList != null ) {
				for ( Psm psm : psmList ) {
					PerPeptideAnnotations perPeptideAnnotations = psm.getPerPeptideAnnotations();
					if ( perPeptideAnnotations != null ) {
						List<PsmPeptide> psmPeptideList = perPeptideAnnotations.getPsmPeptide();
						for ( PsmPeptide psmPeptide : psmPeptideList ) {
							String psmPeptideUniqueId =	psmPeptide.getUniqueId();
							if ( StringUtils.isEmpty( psmPeptideUniqueId ) ) {
								String msg = "psm_peptide unique_id value is empty under reported peptide id: " + reportedPeptide.getReportedPeptideString();
								log.error( msg );
								throw new ProxlImporterDataException( msg );
							}
							if ( ! peptideUniqueIds.contains( psmPeptideUniqueId ) ) {
								String msg = "psm_peptide unique_id value is not on any peptide under same reported peptide id. unique_id: " + psmPeptideUniqueId
										+ ", reported peptide id: " + reportedPeptide.getReportedPeptideString();
								log.error( msg );
								throw new ProxlImporterDataException( msg );
							}
						}
					}
				}
			}
		}
	}

}


text:
aliases:
  - /category/safire/news/
date: 2016-09-14 06:49:47+00:00
layout: taxonomy
menu:
  main:
    identifier: safire-news
    parent: safire
    weight: 1
slug: news
tags:
  - news
title: News
url: /safire/news/
---

News and announcements concerning the South African Identity Federation.


text:
<?php

if (!defined('FERNICO')) {
    fernico_destroy();
}

/*
 * This class (and function) can be used to retrieve settings by their keys.
 * This function returns the settings arrays set in config/config.php.
 */

class Config {

    public static function fetch($key) {

        global $global_fernico_settings;

        if (isset($global_fernico_settings[$key])) {

            return $global_fernico_settings[$key];

        } else {

            return null;

        }

    }

}


text:
namespace ebc {

std::unique_ptr<BitcodeContainer> EmbeddedXar::GetAsBitcodeArchive() const {
  auto bitcodeArchive = BitcodeArchive::BitcodeArchiveFromFile(GetName());
  bitcodeArchive->GetBinaryMetadata().SetFileName(GetName());
  return bitcodeArchive;
}
}  // namespace ebc


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="Read about my adventures, relationships, and traumas. Continue on about my thoughts, thought processes, principles, and wrongdoings.  Hear me judge but never judge me. Or I'll blacklist you from this blog.
">

    <title>Leaving A Legacy (or at least ranting)</title>

    <link rel="canonical" href="/page3/">

    <link rel="stylesheet" href="/css/bootstrap.min.css">

    <link rel="stylesheet" href="/css/clean-blog.css">

    <link rel="stylesheet" href="/css/syntax.css">

    <link href="//maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href='//fonts.googleapis.com/css?family=Lora:400,700,400italic,700italic' rel='stylesheet' type='text/css'>
    <link href='//fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>

            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
                Toggle navigation

            </button>
            Leaving A Legacy (or at least ranting)

                    Main Site

                    Home

                    School

                    Travel

Leaving A Legacy (or at least ranting)

                    i am tali, hear me roar

            All The CT Clubs/Bars We've Dominated (or at least visited)

            we r crazyyy

Posted by Tali M. on June 12, 2015

        ← Newer Posts

Copyright © Leaving A Legacy (or at least ranting) 2015


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>Cyber Fit</title>
  <meta name="description" content="">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="bower_components/html5-boilerplate/dist/css/normalize.css">
  <link rel="stylesheet" href="bower_components/html5-boilerplate/dist/css/main.css">
  <link rel="stylesheet" href="bower_components/material-design-lite/material.min.css">
  <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons">
  <link rel="stylesheet" href="app.css">

        Cyber Fit

          note_add
          Cadastrar Treino

          flash_on
          Treinar


text:
title: PhpStorm Interaction
weight: 8
---

# Extending PhpStorm

> **Note**
> When using Laravel Idea plugin all directives are automatically added.

You may wish to extend PhpStorm to support Blade Directives of this package.

1. In PhpStorm, open Preferences, and navigate to **Languages and Frameworks -> PHP -> Blade**
(File | Settings | Languages & Frameworks | PHP | Blade)
2. Uncheck "Use default settings", then click on the `Directives` tab.
3. Add the following new directives for the laravel-permission package:

**role**

- has parameter = YES
- Prefix: `<?php if(\\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasRole', {`
- Suffix: `})): ?>`

--

**elserole**

- has parameter = YES
- Prefix: `<?php elseif(\\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasRole', {`
- Suffix: `})): ?>`

**endrole**

- has parameter = NO
- Prefix: blank
- Suffix: blank

--

**hasrole**

- has parameter = YES
- Prefix: `<?php if(\\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasRole', {`
- Suffix: `})): ?>`

--

**endhasrole**

- has parameter = NO
- Prefix: blank
- Suffix: blank

--

**hasanyrole**

- has parameter = YES
- Prefix: `<?php if(\\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasAnyRole', {`
- Suffix: `})): ?>`

--

**endhasanyrole**

- has parameter = NO
- Prefix: blank
- Suffix: blank

--

**hasallroles**

- has parameter = YES
- Prefix: `<?php if(\\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasAllRoles', {`
- Suffix: `})): ?>`

--

**endhasallroles**

- has parameter = NO
- Prefix: blank
- Suffix: blank

--

**unlessrole**

- has parameter = YES
- Prefix: `<?php if(! \\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasRole', {`
- Suffix: `})): ?>`

--

**endunlessrole**

- has parameter = NO
- Prefix: blank
- Suffix: blank

--

**hasexactroles**

- has parameter = YES
- Prefix: `<?php if(\\Spatie\\Permission\\PermissionServiceProvider::bladeMethodWrapper('hasExactRoles', {`
- Suffix: `})): ?>`

--

**endhasexactroles**

- has parameter = NO
- Prefix: blank
- Suffix: blank


text:
package workbench.storage;

import java.util.List;
import workbench.TestUtil;
import workbench.db.TableIdentifier;
import workbench.util.WbFile;
import static org.junit.Assert.*;
import org.junit.Test;

/**
 *
 * @author Thomas Kellerer
 */
public class PkMappingTest
{

	@Test
	public void testMapping()
	{
		TestUtil util = new TestUtil("PkMappingTest");
		WbFile f = new WbFile(util.getBaseDir(), "mapping_test.properties");
		PkMapping map = new PkMapping(f.getFullPath());
		TableIdentifier tbl = new TableIdentifier("PERSON");
		map.addMapping(tbl, "id");

		TableIdentifier tbl2 = new TableIdentifier("person");
		List<String> col = map.getPKColumns(tbl2);
		assertEquals(1, col.size());
		assertEquals("id", col.get(0));
	}
}


text:
package org.publo.controller.utils;

import org.junit.Test;
import static org.junit.Assert.*;

public class FileUtilsTest {

    @Test
    public void testGetBasename() throws Exception {
        final String basename = "abc";
        final String extension = ".txt";
        final String result = FileUtils.getBaseName(basename + extension);
        assertEquals(basename, result);
    }

    @Test
    public void testGetBasenameNoExtension() throws Exception {
        final String basename = "abc";
        final String result = FileUtils.getBaseName(basename);
        assertEquals(basename, result);
    }

    @Test
    public void testGetExtension() throws Exception {
        final String basename = "abc";
        final String extension = ".txt";
        final String result = FileUtils.getExtension(basename + extension);
        assertEquals(extension, result);
    }

    @Test
    public void testGetExtensionNoExtension() throws Exception {
        final String basename = "abc";
        final String result = FileUtils.getExtension(basename);
        assertEquals("", result);
    }
}


text:
from datetime import datetime
from urlparse import urlparse

import PyRSS2Gen
from dateutil.parser import parse as parse_datetime
from google.appengine.api import urlfetch
from typing import List
from webapp2 import RequestHandler

from mcfw.exceptions import HttpException
from mcfw.rpc import arguments, returns
from solutions.common.utils import html_to_markdown

class RssCoronavirusDotBeHandler(RequestHandler):
    def get(self):
        url = self.request.params.get('url', 'https://www.info-coronavirus.be/nl/news')
        self.response.headers['Content-Type'] = 'application/rss+xml'
        self.response.out.write(get_coronavirus_dot_be_rss(url))

@returns(unicode)
@arguments(url=unicode)
def get_coronavirus_dot_be_rss(url):
    from bs4 import BeautifulSoup, Tag
    parsed_url = urlparse(url)
    base_url = '%s://%s' % (parsed_url.scheme, parsed_url.netloc)
    fetch_result = urlfetch.fetch(url)  # type: urlfetch._URLFetchResult
    if fetch_result.status_code != 200:
        raise HttpException.from_urlfetchresult(fetch_result)
    soup = BeautifulSoup(fetch_result.content, features='lxml')
    ul = soup.find('ul', {'class': 'blog-list'})
    articles = ul.find_all('li')  # type: List[Tag]
    items = []
    for article in articles:
        link_tag = article.find('a')  # type: Tag
        link = link_tag.attrs['href']
        if link.startswith('/'):
            link = base_url + link
        items.append(PyRSS2Gen.RSSItem(
            link=link,
            title=link_tag.text
        ))
        if len(items) >= 5:
            break
    rpcs = []
    for item in items:
        rpc = urlfetch.create_rpc(10)
        urlfetch.make_fetch_call(rpc, item.link)
        rpcs.append(rpc)
    for item, rpc in zip(items, rpcs):
        result = rpc.get_result()  # type: urlfetch._URLFetchResult
        if result.status_code != 200:
            raise HttpException.from_urlfetchresult(fetch_result)
        item_soup = BeautifulSoup(result.content, features='lxml')
        article = item_soup.find('article')
        item.pubDate = parse_datetime(article.find('time').attrs['datetime'])
        # Remove the header containing the title and date
        article.find('header').extract()
        item.description = html_to_markdown(unicode(article))
    rss = PyRSS2Gen.RSS2(
        title=soup.find('title').text.strip(),
        link=soup.find('meta', {'name': 'description'}).attrs['content'],
        description=soup.find('meta', {'name': 'description'}).attrs['content'],
        lastBuildDate=datetime.utcnow(),
        items=items)
    return rss.to_xml('utf-8')


text:
<?php namespace Jacopo\Authentication\Exceptions;
/**
 * Class ProfileNotFoundException
 *
 * @author jacopo beschi jacopo@jacopobeschi.com
 */

use Exception;
use Jacopo\Library\Exceptions\JacopoExceptionsInterface;

class ProfileNotFoundException extends Exception implements JacopoExceptionsInterface {}


text:
package redis_backend

import (
	"crypto/x509"
	"github.com/leanovate/microzon-auth-go/common"
	"github.com/leanovate/microzon-auth-go/config"
	"github.com/leanovate/microzon-auth-go/logging"
	"sync"
	"time"
)

type redisStore struct {
	lock                sync.RWMutex
	connector           redisConnector
	logger              logging.Logger
	config              *config.StoreConfig
	revocationsListener *redisRevocationsListener
}

func NewRedisStore(config *config.StoreConfig, parent logging.Logger) (*redisStore, error) {
	logger := parent.WithContext(map[string]interface{}{"package": "store.redis_backend"})
	logger.Infof("Start store with redis backend: %s", config.RedisAddress)

	redisStore := &redisStore{
		connector: newRedisConnector(config),
		logger:    logger,
		config:    config,
	}

	return redisStore, nil
}

func (r *redisStore) AllCertificates() ([]*x509.Certificate, error) {
	return r.scanCertificates()
}

func (r *redisStore) FindCertificate(thumbprint string) (*x509.Certificate, error) {
	return r.getCertificateByX5t(thumbprint)
}

func (r *redisStore) AddRevocation(sha256 common.RawSha256, expiresAt time.Time) error {
	return r.insertRevocation(sha256, expiresAt)
}

func (r *redisStore) SetRevocationsListener(listener common.RevocationsListener) error {
	revocationsListener, err := newRedisRevocationsListener(r.connector, listener, r.logger)
	if err != nil {
		return err
	}
	r.revocationsListener = revocationsListener
	return nil
}

func (r *redisStore) Close() {
	r.logger.Info("Closing store with redis backend...")
	r.connector.close()
}


text:
package com.amazonaws.services.directory.model;

import java.io.Serializable;

/**
 *

 * Contains the results of the CreateDirectory operation.
 *

 */
public class CreateDirectoryResult implements Serializable, Cloneable {

    /**
     *

     * The identifier of the directory that was created.
     *

     */
    private String directoryId;

    /**
     *

     * The identifier of the directory that was created.
     *

     *
     * @param directoryId
     *        The identifier of the directory that was created.
     */
    public void setDirectoryId(String directoryId) {
        this.directoryId = directoryId;
    }

    /**
     *

     * The identifier of the directory that was created.
     *

     *
     * @return The identifier of the directory that was created.
     */
    public String getDirectoryId() {
        return this.directoryId;
    }

    /**
     *

     * The identifier of the directory that was created.
     *

     *
     * @param directoryId
     *        The identifier of the directory that was created.
     * @return Returns a reference to this object so that method calls can be
     *         chained together.
     */
    public CreateDirectoryResult withDirectoryId(String directoryId) {
        setDirectoryId(directoryId);
        return this;
    }

    /**
     * Returns a string representation of this object; useful for testing and
     * debugging.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getDirectoryId() != null)
            sb.append("DirectoryId: " + getDirectoryId());
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;

        if (obj instanceof CreateDirectoryResult == false)
            return false;
        CreateDirectoryResult other = (CreateDirectoryResult) obj;
        if (other.getDirectoryId() == null ^ this.getDirectoryId() == null)
            return false;
        if (other.getDirectoryId() != null
                && other.getDirectoryId().equals(this.getDirectoryId()) == false)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime
                * hashCode
                + ((getDirectoryId() == null) ? 0 : getDirectoryId().hashCode());
        return hashCode;
    }

    @Override
    public CreateDirectoryResult clone() {
        try {
            return (CreateDirectoryResult) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new IllegalStateException(
                    "Got a CloneNotSupportedException from Object.clone() "
                            + "even though we're Cloneable!", e);
        }
    }
}


text:
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Main where

import Control.Monad
import Control.Applicative
import Data.Monoid
import Data.Aeson
import Data.Maybe
import Data.Text (Text)
import qualified Data.Text.IO as IO
import System.Random

import DSL
import Server

main = do
        ts <- send (Session session) $ do
                say "Hello!"
                say "Hello!"
                t1 <- temperature
                t2 <- temperature
                t3 <- temperature
                say "Howdy"
                return [t1,t2,t3]
        print ts


text:
'use strict';

const fs = require('fs');
const path = require('path');
const Sequelize = require('sequelize');
const basename = path.basename(module.filename);
const config = require('../config');
const db = {};

let cfg = {};
Object.assign(cfg, config);

// common options for sequelize.define
cfg.define = {
    timestamps: false,
    underscored: true
};

const sequelize = new Sequelize(cfg.database, cfg.username, cfg.password, cfg);

/**
 * Scan models in the 'dir' directory.
 */
const scanDir = function (dir, excludes = []) {
    fs.readdirSync(dir)
        .filter(file => {
            return (file.indexOf('.') !== 0) &&
                (file !== basename) &&
                (file.slice(-3) === '.js') &&
                excludes.indexOf(file) < 0;
        })
        .forEach(file => {
            const model = sequelize.import(path.join(dir, file));
            db[model.name] = model;
        });

    // associate relations
    Object.keys(db).forEach(modelName => {
        if (db[modelName].associate) {
            db[modelName].associate(db);
        }
    });
};

const excludes = [
    'model_helper.js'
];
scanDir(__dirname, excludes);

db.sequelize = sequelize;
db.Sequelize = Sequelize;
db.scanDir = scanDir;

module.exports = db;


text:
<TITLE>Review for Hanging Up (2000)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Hanging Up (2000)

reviewed by
Ross Anthony

Cell Phone Mania
Hanging Up

By Ross Anthony

An over-burdened Meg Ryan runs around town tending to everyone else's needs,
but her own. She remains mostly in good humor while doused with an
inharmonious silly physical comedy. Example: The phone rings and Meg answers
the TV remote.

Meg's Father (Matthau) is hilariously incoherent too deeply touching too
terminally ill. "How is it that a man can't recognize his own pants, but he
remembers his daughter's phone number." Matthau is wonderful, without him
"Hanging up" would have been completely "Disconnected." Kudrow, Keaton and
Ryan all give strong performances.

Aside from some early exposition, the dialogue is very good, very
re-written, and sharply detailed; however, the story line feels like a first
draft. What happens to Meg's kids as she tends to everyone else? After the
first 15 minutes, they're gone. We're teased into anticipating a plane crash
that never happens. And an interesting character (Dr. Amond) is left
undeveloped and un-used.

The intent was to portray a slice of the life of a good person with a
bleeding heart personality who is totally exhausting herself, but the
byproduct of that is ... we get exhausted along with her.

You might lose some sympathy when Meg tears a page from a public phone book
while driving to her estranged mother's house. Besides being a bit out of
character, that is so rude! What about the next person whose mother's maiden
name starts with the same letter?

In the end we have a film that touches on Meg's relationships with her
sisters and with her father and with herself in a on-again-off-again
humorous way, but without a great story to hold onto.

Hanging Up. Copyright © 2000. Rated PG-13.
Starring Meg Ryan, Diane Keaton, Lisa Kudrow, Walter Matthau
Directed by Diane Keaton
Screenplay by Delia Ephron and Nora Ephron
Produced by Laurence Mark and Nora Ephron at Columbia Pictures.

Grade..........................B
--
Copyright © 2000. Ross Anthony, currently based in Los Angeles, has scripted
and shot documentaries, music videos, and shorts in 35 countries across
North America, Europe, Africa and Asia. For more reviews visit:
http://RossAnthony.com

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
function userAI.onKeyboardKeyDown ( kKeyCode )
--------------------------------------------------------------------------------

    --Send the button state to the jumpManAI and set the debug HUD to green

	if(kKeyCode == input.kKeyRight)
    then
        object.sendEvent ( this.hPlayer ( ), "jumpManAI", "onMoveRight", true )
        local hRight = hud.getComponent ( this.getUser ( ), "hud.rightStatus" )
        hud.setComponentBackgroundColor ( hRight, 0, 127, 0, 255 )
    elseif(kKeyCode == input.kKeyLeft)
    then
        object.sendEvent ( this.hPlayer ( ), "jumpManAI", "onMoveLeft", true )
        local hLeft = hud.getComponent ( this.getUser ( ), "hud.leftStatus" )
        hud.setComponentBackgroundColor ( hLeft, 0, 127, 0, 255 )
    elseif(kKeyCode == input.kKeySpace)
    then
        object.sendEvent ( this.hPlayer ( ), "jumpManAI", "onJump", true )
        local hJump = hud.getComponent ( this.getUser ( ), "hud.jumpStatus" )
        hud.setComponentBackgroundColor ( hJump, 0, 127, 0, 255 )
    end

--------------------------------------------------------------------------------
end
--------------------------------------------------------------------------------


text:
const ZoneController = require('./ZoneController');
const CommentController = require('./CommentController');

module.exports = {
  comment: CommentController,
  zone: ZoneController
}


text:
package org.jaudiotagger.tag.id3;

/**
 * Categorises id3 fields to aid in mapping to generic keys
 */
public enum Id3FieldType
{
    TEXT,
    USER_DEFINED_TEXT,
    BINARY
}


text:
<?php

/**
 * Item types form.
 *
 * @package Omeka\Form
 */
class Omeka_Form_ItemTypes extends Omeka_Form
{
    // form id
    const FORM_ID = 'item-type-form';

    // form element ids
    const NAME_ELEMENT_ID = 'itemtypes_name';
    const DESCRIPTION_ELEMENT_ID = 'itemtypes_description';
    const REMOVE_HIDDEN_ELEMENT_ID = 'itemtypes_remove';
    const SUBMIT_EDIT_ELEMENT_ID = 'itemtypes_edit_submit';
    const SUBMIT_ADD_ELEMENT_ID = 'itemtypes_add_submit';

    // input names
    const ELEMENTS_INPUT_NAME = 'elements';
    const ELEMENTS_TO_ADD_INPUT_NAME = 'elements-to-add';
    const NEW_ELEMENTS_INPUT_NAME = 'new-elements';

    private $_itemType;  // the item type for the form

    /*
       An info array for each item type element in the item type
       each elementInfo contains the following keys:

       'element' => the item type element object
       'temp_id' => the temporary form element id for
                    item type elements that have not yet been added to the item type
    */
    private $_elementInfos;

    public function init()
    {
        parent::init();
        $this->setAttrib('id', self::FORM_ID);
    }

    public function setItemType($itemType)
    {
        $this->_itemType = $itemType;
        $this->_initElements();
    }

    public function getElementInfos()
    {
        return $this->_elementInfos;
    }

    public function saveFromPost()
    {
        if ($_POST) {
            if (!$this->_itemType) {
                $this->_itemType = new ItemType;
            }

            // get the item type element infos from post
            $this->_elementInfos = $this->_getElementInfosFromPost();

            // make sure that there are no duplicates in item type elements
            $this->_checkForDuplicateElements();

            // remove old item type elements from post
            $this->_removeElementsFromItemType();

            // add elements to the item type
            $this->_addElementsToItemType();

            // set the name and description of the item type
            $this->_itemType->name = $this->getValue(self::NAME_ELEMENT_ID);
            $this->_itemType->description = $this->getValue(self::DESCRIPTION_ELEMENT_ID);

            // save the item type
            if ($this->_itemType->save()) {
                // reorder the item type's elements
                $this->_reorderItemTypeElements();
            }
        }

        return $this->_itemType;
    }

    private function _addElementsToItemType()
    {
        $elements = array();
        foreach($this->_elementInfos as $elementInfo) {
            $elements[] = $elementInfo['element'];
        }

        $this->_itemType->addElements($elements);
    }

    private function _reorderItemTypeElements()
    {
        $elementOrders = array();
        foreach($this->_elementInfos as $elementInfo) {
            $elementOrders[$elementInfo['element']['id']] = $elementInfo['order'];
        }
        $this->_itemType->reorderElements($elementOrders);
    }

    private function _initElements()
    {
        // set the item type name and description
        $itemTypeName = '';
        $itemTypeDescription = '';
        if ($this->_itemType) {
             $itemTypeName  = $this->_itemType->name;
             $itemTypeDescription  = $this->_itemType->description;
        }

        // set the default element infos
        $this->_elementInfos = array();
        if ($this->_itemType) {
            $elementOrder = 1;
            foreach($this->_itemType->Elements as $element) {
                $elementInfo = array(
                    'element' => $element,
                    'temp_id' => null,
                    'order' => $elementOrder,
                );
                $this->_elementInfos[] = $elementInfo;
                $elementOrder++;
            }
        }

        $this->clearElements();

        $this->addElement('text', self::NAME_ELEMENT_ID,
            array(
                'label' => __('Name'),
                'description' => __('The name of the item type.'),
                'required' => true,
                'value' => $itemTypeName,
            )
        );

        $this->addElement('textarea', self::DESCRIPTION_ELEMENT_ID,
            array(
                'label' => __('Description'),
                'description' => __('The description of the item type.'),
                'value' => $itemTypeDescription,
                'cols' => 50,
                'rows' => 5,
            )
        );

        $this->addElement('hidden', self::REMOVE_HIDDEN_ELEMENT_ID, array('value' => ''));
        $this->addElement('sessionCsrfToken', 'csrf_token');
    }

    private function _checkForDuplicateElements()
    {
        // Check for duplicate elements and throw an exception if a duplicate is found
        $elementIds = array();
        $elementNames = array();
        foreach($this->_elementInfos as $elementInfo) {
            $element = $elementInfo['element'];

            // prevent duplicate item type element ids
            if ($element->id) {
                if (in_array($element->id, $elementIds)) {
                    throw new Omeka_Validate_Exception(__('The item type cannot have more than one "%s" element.', $element->name));
                } else {
                    $elementIds[] = $element->id;
                }
            }

            // prevent duplicate item type element names
            if ($element->name) {
                if (in_array($element->name, $elementNames)) {
                    throw new Omeka_Validate_Exception(__('The item type cannot have more than one "%s" element.', $element->name));
                } else {
                    $elementNames[] = trim($element->name);
                }
            }
        }
    }

    private function _removeElementsFromItemType()
    {
        $elementTable = get_db()->getTable('Element');
        // get the item type element ids to remove from the post and remove those elements from the item type
        $elementIds = explode(',', $this->getValue(self::REMOVE_HIDDEN_ELEMENT_ID));
        foreach($elementIds as $elementId) {
            $elementId = intval(trim($elementId));
            if ($elementId) {
                if ($element = $elementTable->find($elementId)) {
                    $this->_itemType->removeElement($element);
                }
            }
        }
    }

    // get the elements to save from the post
    private function _getElementInfosFromPost()
    {
        $elementTable = get_db()->getTable('Element');
        $elementInfos = array();

        if (isset($_POST[self::ELEMENTS_INPUT_NAME])) {
            $currentElements = $_POST[self::ELEMENTS_INPUT_NAME];
            foreach ($currentElements as $elementId => $info) {
                $elementInfos[] = array(
                    'element' => $elementTable->find($elementId),
                    'temp_id' => null,
                    'order' => $info['order']
                );
            }
        }

        if (isset($_POST[self::ELEMENTS_TO_ADD_INPUT_NAME])) {
            $elementsToAdd = $_POST[self::ELEMENTS_TO_ADD_INPUT_NAME];
            foreach ($elementsToAdd as $tempId => $info) {
                if (empty($info['id'])) {
                    continue;
                }

                $elementInfos[] = array(
                    'element' => $elementTable->find($info['id']),
                    'temp_id' => $tempId,
                    'order' => $info['order']
                );
            }
        }

        if (isset($_POST[self::NEW_ELEMENTS_INPUT_NAME])) {
            $newElements = $_POST[self::NEW_ELEMENTS_INPUT_NAME];
            foreach ($newElements as $tempId => $info) {
                if (empty($info['name'])) {
                    continue;
                }

                $element = new Element;
                $element->setElementSet(ElementSet::ITEM_TYPE_NAME);
                $element->setName($info['name']);
                $element->setDescription($info['description']);
                $element->order = null;

                $elementInfos[] = array(
                    'element' => $element,
                    'temp_id' => $tempId,
                    'order' => $info['order']
                );
            }
        }

        return $elementInfos;
    }
}


text:
package org.locationtech.geowave.cli.osm.osmfeature.types.features;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.locationtech.geowave.cli.osm.osmfeature.types.attributes.AttributeDefinition;

public class FeatureDefinition {
  public String name = null;
  public FeatureType type = null;
  public final Map<String, List<String>> mappings = new HashMap<>();
  public final Map<String, List<Map<String, List<String>>>> subMappings = new HashMap<>();
  public final List<AttributeDefinition> attributes = new ArrayList<>();
  public final List<Map<String, List<String>>> filters = new ArrayList<>();
  public final List<String> mappingKeys = new ArrayList<>();
  private static final String WILDCARD_ATTRIBUTE = "__any__";

  public String getMappingName() {
    for (final AttributeDefinition ad : attributes) {
      if (ad.type.equals("mapping_value")) {
        return ad.name;
      }
    }
    return null;
  }

  public AttributeDefinition getMappingAttribute() {
    for (final AttributeDefinition ad : attributes) {
      if (ad.type.equals("mapping_value")) {
        return ad;
      }
    }
    return null;
  }

  public String getQualifiedSubMappings() {
    for (final AttributeDefinition ad : attributes) {
      if (ad.type.equals("mapping_key")) {
        return ad.name;
      }
    }
    return null;
  }

  public AttributeDefinition getSubMappingAttribute() {
    for (final AttributeDefinition ad : attributes) {
      if (ad.type.equals("mapping_key")) {
        return ad;
      }
    }
    return null;
  }

  public boolean isMappedValue(final String val) {
    for (final Map.Entry<String, List<String>> map : mappings.entrySet()) {
      if (map.getValue().contains(WILDCARD_ATTRIBUTE) || map.getValue().contains(val)) {
        return true;
      }
    }
    return false;
  }

  public String getSubMappingClass(final String key, final String val) {
    for (final Map.Entry<String, List<Map<String, List<String>>>> m : subMappings.entrySet()) {
      for (final Map<String, List<String>> m2 : m.getValue()) {
        for (final Map.Entry<String, List<String>> m3 : m2.entrySet()) {
          if (m3.getKey().equals(key)) {
            if (m3.getValue().contains(WILDCARD_ATTRIBUTE) || m3.getValue().contains(val)) {
              return m3.getKey();
            }
          }
        }
      }
    }
    return null;
  }
}