You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
316 lines
11 KiB
316 lines
11 KiB
/** |
|
* Announcer for `ACommandFeature`. |
|
* Copyright 2022 Anton Tarasenko |
|
*------------------------------------------------------------------------------ |
|
* This file is part of Acedia. |
|
* |
|
* Acedia is free software: you can redistribute it and/or modify |
|
* it under the terms of the GNU General Public License as published by |
|
* the Free Software Foundation, version 3 of the License, or |
|
* (at your option) any later version. |
|
* |
|
* Acedia is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
* GNU General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU General Public License |
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
|
*/ |
|
class ACommandFeature_Announcer extends CommandAnnouncer; |
|
|
|
var private AnnouncementVariations enabledFeature, disabledFeature; |
|
var private AnnouncementVariations swappedConfig; |
|
var private AnnouncementVariations showCurrentConfig, showPendingConfig; |
|
var private AnnouncementVariations failedToLoadFeatureClass; |
|
var private AnnouncementVariations failedNoConfigProvided, failedConfigMissing; |
|
var private AnnouncementVariations failedCannotEnableFeature; |
|
var private AnnouncementVariations failedNoConfigClass; |
|
var private AnnouncementVariations failedAlreadyEnabled, failedAlreadyDisabled; |
|
var private AnnouncementVariations failedNoDataForConfig, failedExpectedObject; |
|
var private AnnouncementVariations failedBadPointer; |
|
|
|
protected function Finalizer() |
|
{ |
|
FreeVariations(enabledFeature); |
|
FreeVariations(disabledFeature); |
|
FreeVariations(swappedConfig); |
|
FreeVariations(showCurrentConfig); |
|
FreeVariations(showPendingConfig); |
|
FreeVariations(failedToLoadFeatureClass); |
|
FreeVariations(failedNoConfigProvided); |
|
FreeVariations(failedConfigMissing); |
|
FreeVariations(failedCannotEnableFeature); |
|
FreeVariations(failedNoConfigClass); |
|
FreeVariations(failedAlreadyEnabled); |
|
FreeVariations(failedAlreadyDisabled); |
|
FreeVariations(failedNoDataForConfig); |
|
FreeVariations(failedExpectedObject); |
|
FreeVariations(failedBadPointer); |
|
super.Finalizer(); |
|
} |
|
|
|
public final function AnnounceEnabledFeature( |
|
class<Feature> featureClass, |
|
BaseText configName) |
|
{ |
|
local int i; |
|
local array<TextTemplate> templates; |
|
|
|
if (!enabledFeature.initialized) |
|
{ |
|
enabledFeature.initialized = true; |
|
enabledFeature.toSelfReport = _.text.MakeTemplate_S( |
|
"Feature {$TextEmphasis `%1`} {$TextPositive enabled} with config" |
|
@ "\"%2\""); |
|
enabledFeature.toSelfPublic = _.text.MakeTemplate_S( |
|
"%%instigator%% {$TextPositive enabled} feature" |
|
@ "{$TextEmphasis `%1`} with config \"%2\""); |
|
} |
|
templates = MakeArray(enabledFeature); |
|
for (i = 0; i < templates.length; i += 1) { |
|
templates[i].Reset().ArgClass(featureClass).Arg(configName); |
|
} |
|
MakeAnnouncement(enabledFeature); |
|
} |
|
|
|
public final function AnnounceDisabledFeature(class<Feature> featureClass) |
|
{ |
|
local int i; |
|
local array<TextTemplate> templates; |
|
|
|
if (!disabledFeature.initialized) |
|
{ |
|
disabledFeature.initialized = true; |
|
disabledFeature.toSelfReport = _.text.MakeTemplate_S( |
|
"Feature {$TextEmphasis `%1`} {$TextNegative disabled}"); |
|
disabledFeature.toSelfPublic = _.text.MakeTemplate_S( |
|
"%%instigator%% {$TextNegative disabled} feature" |
|
@ "{$TextEmphasis `%1`}"); |
|
} |
|
templates = MakeArray(disabledFeature); |
|
for (i = 0; i < templates.length; i += 1) { |
|
templates[i].Reset().ArgClass(featureClass); |
|
} |
|
MakeAnnouncement(disabledFeature); |
|
} |
|
|
|
public final function AnnounceSwappedConfig( |
|
class<Feature> featureClass, |
|
BaseText oldConfig, |
|
BaseText newConfig) |
|
{ |
|
local int i; |
|
local array<TextTemplate> templates; |
|
|
|
if (!swappedConfig.initialized) |
|
{ |
|
swappedConfig.initialized = true; |
|
swappedConfig.toSelfReport = _.text.MakeTemplate_S( |
|
"Config for feature {$TextEmphasis `%1`} {$TextNeutral swapped}" |
|
@ "from \"%2\" to \"%3\""); |
|
swappedConfig.toSelfPublic = _.text.MakeTemplate_S( |
|
"%%instigator%% {$TextNeutral swapped} config for feature" |
|
@ "{$TextEmphasis `%1`} from \"%2\" to \"%3\""); |
|
} |
|
templates = MakeArray(swappedConfig); |
|
for (i = 0; i < templates.length; i += 1) |
|
{ |
|
templates[i] |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(oldConfig) |
|
.Arg(newConfig); |
|
} |
|
MakeAnnouncement(swappedConfig); |
|
} |
|
|
|
public final function AnnounceCurrentConfig( |
|
class<Feature> featureClass, |
|
BaseText config) |
|
{ |
|
if (!showCurrentConfig.initialized) |
|
{ |
|
showCurrentConfig.initialized = true; |
|
showCurrentConfig.toSelfReport = _.text.MakeTemplate_S( |
|
"Current config \"%2\" for feature {$TextEmphasis `%1`}:"); |
|
} |
|
showCurrentConfig.toSelfReport |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(config); |
|
MakeAnnouncement(showCurrentConfig); |
|
} |
|
|
|
public final function AnnouncePendingConfig( |
|
class<Feature> featureClass, |
|
BaseText config) |
|
{ |
|
if (!showPendingConfig.initialized) |
|
{ |
|
showPendingConfig.initialized = true; |
|
showPendingConfig.toSelfReport = _.text.MakeTemplate_S( |
|
"Pending config \"%2\" for feature {$TextEmphasis `%1`}:"); |
|
} |
|
showPendingConfig.toSelfReport |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(config); |
|
MakeAnnouncement(showPendingConfig); |
|
} |
|
|
|
public final function AnnounceFailedToLoadFeatureClass(BaseText failedClassName) |
|
{ |
|
if (!failedToLoadFeatureClass.initialized) |
|
{ |
|
failedToLoadFeatureClass.initialized = true; |
|
failedToLoadFeatureClass.toSelfReport = _.text.MakeTemplate_S( |
|
"{$TextFailure Failed} to load feature class {$TextEmphasis `%1`}"); |
|
} |
|
failedToLoadFeatureClass.toSelfReport.Reset().Arg(failedClassName); |
|
MakeAnnouncement(failedToLoadFeatureClass); |
|
} |
|
|
|
public final function AnnounceFailedNoConfigProvided( |
|
class<Feature> featureClass) |
|
{ |
|
if (!failedNoConfigProvided.initialized) |
|
{ |
|
failedNoConfigProvided.initialized = true; |
|
failedNoConfigProvided.toSelfReport = _.text.MakeTemplate_S( |
|
"{$TextFailure No config specified} and {$TextFailure no" |
|
@ "auto-enabled config} exists for feature {$TextEmphasis `%1`}"); |
|
} |
|
failedNoConfigProvided.toSelfReport.Reset().ArgClass(featureClass); |
|
MakeAnnouncement(failedNoConfigProvided); |
|
} |
|
|
|
public final function AnnounceFailedConfigMissing(BaseText config) |
|
{ |
|
if (!failedConfigMissing.initialized) |
|
{ |
|
failedConfigMissing.initialized = true; |
|
failedConfigMissing.toSelfReport = _.text.MakeTemplate_S( |
|
"Specified config \"%1\" {$TextFailure doesn't exist}"); |
|
} |
|
failedConfigMissing.toSelfReport.Reset().Arg(config); |
|
MakeAnnouncement(failedConfigMissing); |
|
} |
|
|
|
public final function AnnounceFailedCannotEnableFeature( |
|
class<Feature> featureClass, |
|
BaseText config) |
|
{ |
|
if (!failedCannotEnableFeature.initialized) |
|
{ |
|
failedCannotEnableFeature.initialized = true; |
|
failedCannotEnableFeature.toSelfReport = _.text.MakeTemplate_S( |
|
"Something went {$TextFailure wrong}, {$TextFailure failed} to" |
|
@ "enable feature {$TextEmphasis `%1`} with config \"%2\""); |
|
} |
|
failedCannotEnableFeature.toSelfReport |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(config); |
|
MakeAnnouncement(failedCannotEnableFeature); |
|
} |
|
|
|
public final function AnnounceFailedNoConfigClass( |
|
class<Feature> featureClass) |
|
{ |
|
if (!failedNoConfigClass.initialized) |
|
{ |
|
failedNoConfigClass.initialized = true; |
|
failedNoConfigClass.toSelfReport = _.text.MakeTemplate_S( |
|
"Feature {$TextEmphasis `%1`} {$TextFailure does not have config" |
|
@ "class}! This is most likely caused by its faulty" |
|
@ "implementation"); |
|
} |
|
failedNoConfigClass.toSelfReport.Reset().ArgClass(featureClass); |
|
MakeAnnouncement(failedNoConfigClass); |
|
} |
|
|
|
public final function AnnounceFailedAlreadyDisabled( |
|
class<Feature> featureClass) |
|
{ |
|
if (!failedAlreadyDisabled.initialized) |
|
{ |
|
failedAlreadyDisabled.initialized = true; |
|
failedAlreadyDisabled.toSelfReport = _.text.MakeTemplate_S( |
|
"Feature {$TextEmphasis `%1`} is already {$TextNegative disabled}"); |
|
} |
|
failedAlreadyDisabled.toSelfReport.Reset().ArgClass(featureClass); |
|
MakeAnnouncement(failedAlreadyDisabled); |
|
} |
|
|
|
public final function AnnounceFailedAlreadyEnabled( |
|
class<Feature> featureClass, |
|
BaseText config) |
|
{ |
|
if (!failedAlreadyEnabled.initialized) |
|
{ |
|
failedAlreadyEnabled.initialized = true; |
|
failedAlreadyEnabled.toSelfReport = _.text.MakeTemplate_S( |
|
"Feature {$TextEmphasis `%1`} is already {$TextNegative enabled}" |
|
@ "with specified config \"%2\""); |
|
} |
|
failedAlreadyEnabled.toSelfReport |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(config); |
|
MakeAnnouncement(failedAlreadyEnabled); |
|
} |
|
|
|
public final function AnnounceFailedNoDataForConfig( |
|
class<Feature> featureClass, |
|
BaseText config) |
|
{ |
|
if (!failedNoDataForConfig.initialized) |
|
{ |
|
failedNoDataForConfig.initialized = true; |
|
failedNoDataForConfig.toSelfReport = _.text.MakeTemplate_S( |
|
"Feature {$TextEmphasis `%1`} is {$TextFailure missing data} for" |
|
@ "config \"%2\""); |
|
} |
|
failedNoDataForConfig.toSelfReport |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(config); |
|
MakeAnnouncement(failedNoDataForConfig); |
|
} |
|
|
|
public final function AnnounceFailedExpectedObject() |
|
{ |
|
if (!failedExpectedObject.initialized) |
|
{ |
|
failedExpectedObject.initialized = true; |
|
failedExpectedObject.toSelfReport = _.text.MakeTemplate_S( |
|
"Value change {$TextFailure failed}, because when changing" |
|
@ "the value of the whole config, a JSON object must be provided"); |
|
} |
|
MakeAnnouncement(failedExpectedObject); |
|
} |
|
|
|
public final function AnnounceFailedBadPointer( |
|
class<Feature> featureClass, |
|
BaseText config, |
|
BaseText pointer) |
|
{ |
|
if (!failedBadPointer.initialized) |
|
{ |
|
failedBadPointer.initialized = true; |
|
failedBadPointer.toSelfReport = _.text.MakeTemplate_S( |
|
"Provided JSON pointer \"%3\" is {$TextFailure invalid} for config" |
|
@ "\"%2\" of feature {$TextEmphasis `%1`}"); |
|
} |
|
failedBadPointer.toSelfReport |
|
.Reset() |
|
.ArgClass(featureClass) |
|
.Arg(config) |
|
.Arg(pointer); |
|
MakeAnnouncement(failedBadPointer); |
|
} |
|
|
|
defaultproperties |
|
{ |
|
} |