/// <summary>
/// Available Maximum Power you can set on specific region
/// </summary>
private uint GetSoftwareMaxPowerLevel(RegionCode region)
{
// MAX Power 32dB
if ((m_oem_hipower == 1) ||
(m_oem_machine == Machine.CS468INT) ||
(m_oem_machine == Machine.CS463) ||
(m_oem_machine == Machine.CS469) ||
(region == RegionCode.IN) ||
(region == RegionCode.G800) ||
(m_oem_machine == Machine.CS209) ||
(m_oem_machine == Machine.CS103) ||
(m_oem_machine == Machine.CS108)
)
{
return(320);
}
// MAX Power 27.5dB
if ((m_oem_machine == Machine.CS101 && region == RegionCode.ETSI) ||
(m_oem_machine == Machine.CS203 && region == RegionCode.JP))
{
return(275);
}
return(300);
}
private string GetRegionCode(RegionCode region)
{
switch (region)
{
case RegionCode.Asia: return("asia");
case RegionCode.Australia: return("au");
case RegionCode.CanadaEast: return("cae");
case RegionCode.Chinese: return("cn");
case RegionCode.Europe: return("eu");
case RegionCode.India: return("in");
case RegionCode.Japan: return("jp");
case RegionCode.Russia: return("ru");
case RegionCode.RussiaEast: return("rue");
case RegionCode.SoutAmerica: return("sa");
case RegionCode.SouthKorea: return("kr");
case RegionCode.USAEast: return("us");
case RegionCode.USAWest: return("usw");
}
return("us");
}
public override int GetHashCode()
{
int hash = 1;
if (Parent.Length != 0)
{
hash ^= Parent.GetHashCode();
}
if (Resume.Length != 0)
{
hash ^= Resume.GetHashCode();
}
if (RegionCode.Length != 0)
{
hash ^= RegionCode.GetHashCode();
}
if (LanguageCode.Length != 0)
{
hash ^= LanguageCode.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public override bool Equals(object obj)
{
if (obj is long l)
{
return(RegionCode == l);
}
return(RegionCode.Equals(obj));
}
public static AuthenticatorRegion Factory(RegionCode regionType)
{
if (regionType == RegionCode.NorthAmerica || regionType == RegionCode.Europe)
{
AuthenticatorRegion region = new AuthenticatorRegion();
region.RegionType = regionType;
return(region);
}
return(null);
}
public string Serialize()
{
StringBuilder builder = new StringBuilder();
AddVar(builder, " Error", Error.ToString(), true);
AddVar(builder, " ErrorString", ErrorString);
AddVar(builder, " LTouchVersion", ((int)LTouchVersion).ToString());
if (XEXCRC != null)
{
AddVar(builder, " XEXCRC", ((int)XEXCRC.Status).ToString() + "|" + XEXCRC.Crc.ToString("X8"));
}
if (VideoCRC != null)
{
AddVar(builder, " VideoCRC", ((int)VideoCRC.Status).ToString() + "|" + VideoCRC.Crc.ToString("X8"));
}
if (V0CRC != null)
{
AddVar(builder, " V0CRC", ((int)V0CRC.Status).ToString() + "|" + V0CRC.Crc.ToString("X8"));
}
if (V1CRC != null)
{
AddVar(builder, " V1CRC", ((int)V1CRC.Status).ToString() + "|" + V1CRC.Crc.ToString("X8"));
}
if (PFICRC != null)
{
AddVar(builder, " PFICRC", ((int)PFICRC.Status).ToString() + "|" + PFICRC.Crc.ToString("X8"));
}
if (DMICRC != null)
{
AddVar(builder, " DMICRC", ((int)DMICRC.Status).ToString() + "|" + DMICRC.Crc.ToString("X8"));
}
if (SSCRC != null)
{
AddVar(builder, " SSCRC", ((int)SSCRC.Status).ToString() + "|" + SSCRC.Crc.ToString("X8"));
}
if (GameCRC != null)
{
AddVar(builder, " GameCRC", ((int)GameCRC.Status).ToString() + "|" + GameCRC.Crc.ToString("X8"));
}
AddVar(builder, " RAWSS", RAWSS.ToString("X8"));
AddVar(builder, " RegionCode", RegionCode.ToString("X8"));
AddVar(builder, " MediaId", MediaId);
AddVar(builder, " AnyDVDCorruption", AnyDVDCorruption.ToString());
AddVar(builder, " MinKernel", MinKernel);
AddVar(builder, " LastCheck", LastCheck.ToString());
AddVar(builder, " Wave", Wave);
AddVar(builder, " Size", Size.ToString());
return(builder.ToString());
}
// GetRegionCode() -> u32 nn::settings::RegionCode
public ResultCode GetRegionCode(ServiceCtx context)
{
// NOTE: Service mount 0x8000000000000050 savedata and read the region code here.
RegionCode regionCode = (RegionCode)context.Device.System.State.DesiredRegionCode;
if (regionCode < RegionCode.Min || regionCode > RegionCode.Max)
{
regionCode = RegionCode.USA;
}
context.ResponseData.Write((uint)regionCode);
return(ResultCode.Success);
}
private static RegionCode[] GetRegionCodes()
{
if (options != null && !options.IncludeRegionCodes)
{
return(null);
}
List <XElement> regionCodeElements = (from i in supplementalDataDocument.Elements("supplementalData")
.Elements("codeMappings").Elements("territoryCodes")
select i).ToList();
if (regionCodeElements == null || regionCodeElements.Count == 0)
{
return(null);
}
List <RegionCode> regionCodes = new List <RegionCode>();
foreach (XElement regionCodeElement in regionCodeElements)
{
string regionId = regionCodeElement.Attribute("type").Value.ToString();
Progress("Adding region code", regionId);
RegionCode regionCode = new RegionCode();
regionCode.RegionId = regionId;
if (regionCodeElement.Attribute("numeric") != null)
{
regionCode.Numeric = regionCodeElement.Attribute("numeric").Value.ToString();
}
if (regionCodeElement.Attribute("alpha3") != null)
{
regionCode.Alpha3 = regionCodeElement.Attribute("alpha3").Value.ToString();
}
if (regionCodeElement.Attribute("fips10") != null)
{
regionCode.Fips10 = regionCodeElement.Attribute("fips10").Value.ToString();
}
regionCodes.Add(regionCode);
Progress("Added region code", regionId, ProgressEventType.Added, regionCode);
}
return(regionCodes.ToArray());
}
public override int GetHashCode()
{
int hash = 1;
if (Revision != 0)
{
hash ^= Revision.GetHashCode();
}
if (RegionCode.Length != 0)
{
hash ^= RegionCode.GetHashCode();
}
if (LanguageCode.Length != 0)
{
hash ^= LanguageCode.GetHashCode();
}
if (PostalCode.Length != 0)
{
hash ^= PostalCode.GetHashCode();
}
if (SortingCode.Length != 0)
{
hash ^= SortingCode.GetHashCode();
}
if (AdministrativeArea.Length != 0)
{
hash ^= AdministrativeArea.GetHashCode();
}
if (Locality.Length != 0)
{
hash ^= Locality.GetHashCode();
}
if (Sublocality.Length != 0)
{
hash ^= Sublocality.GetHashCode();
}
hash ^= addressLines_.GetHashCode();
hash ^= recipients_.GetHashCode();
if (Organization.Length != 0)
{
hash ^= Organization.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public HLEConfiguration(VirtualFileSystem virtualFileSystem,
LibHacHorizonManager libHacHorizonManager,
ContentManager contentManager,
AccountManager accountManager,
UserChannelPersistence userChannelPersistence,
IRenderer gpuRenderer,
IHardwareDeviceDriver audioDeviceDriver,
MemoryConfiguration memoryConfiguration,
IHostUiHandler hostUiHandler,
SystemLanguage systemLanguage,
RegionCode region,
bool enableVsync,
bool enableDockedMode,
bool enablePtc,
bool enableInternetAccess,
IntegrityCheckLevel fsIntegrityCheckLevel,
int fsGlobalAccessLogMode,
long systemTimeOffset,
string timeZone,
MemoryManagerMode memoryManagerMode,
bool ignoreMissingServices,
AspectRatio aspectRatio,
float audioVolume)
{
VirtualFileSystem = virtualFileSystem;
LibHacHorizonManager = libHacHorizonManager;
AccountManager = accountManager;
ContentManager = contentManager;
UserChannelPersistence = userChannelPersistence;
GpuRenderer = gpuRenderer;
AudioDeviceDriver = audioDeviceDriver;
MemoryConfiguration = memoryConfiguration;
HostUiHandler = hostUiHandler;
SystemLanguage = systemLanguage;
Region = region;
EnableVsync = enableVsync;
EnableDockedMode = enableDockedMode;
EnablePtc = enablePtc;
EnableInternetAccess = enableInternetAccess;
FsIntegrityCheckLevel = fsIntegrityCheckLevel;
FsGlobalAccessLogMode = fsGlobalAccessLogMode;
SystemTimeOffset = systemTimeOffset;
TimeZone = timeZone;
MemoryManagerMode = memoryManagerMode;
IgnoreMissingServices = ignoreMissingServices;
AspectRatio = aspectRatio;
AudioVolume = audioVolume;
}
public override int GetHashCode()
{
unchecked
{
int hashCode = LocationId.GetHashCode();
hashCode = (hashCode * 397) ^ (CountryCode != null ? CountryCode.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (RegionCode != null ? RegionCode.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (CityName != null ? CityName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (PostalCode != null ? PostalCode.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Latitude.GetHashCode();
hashCode = (hashCode * 397) ^ Longitude.GetHashCode();
hashCode = (hashCode * 397) ^ MetroCode.GetHashCode();
hashCode = (hashCode * 397) ^ (AreaCode != null ? AreaCode.GetHashCode() : 0);
return(hashCode);
}
}
public override int GetHashCode()
{
int hash = 1;
if (RegionCode.Length != 0)
{
hash ^= RegionCode.GetHashCode();
}
if (Number.Length != 0)
{
hash ^= Number.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset.createTime)
{
hashcode = (hashcode * 397) + CreateTime.GetHashCode();
}
if (__isset.regionCode)
{
hashcode = (hashcode * 397) + RegionCode.GetHashCode();
}
if (__isset.identities)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(Identities);
}
}
return(hashcode);
}
public override string ToString()
{
var sb = new StringBuilder("MetaProfile(");
bool __first = true;
if (__isset.createTime)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("CreateTime: ");
CreateTime.ToString(sb);
}
if (RegionCode != null && __isset.regionCode)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("RegionCode: ");
RegionCode.ToString(sb);
}
if (Identities != null && __isset.identities)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("Identities: ");
Identities.ToString(sb);
}
sb.Append(")");
return(sb.ToString());
}
public override int GetHashCode()
{
return(key.GetHashCode() ^ CoordComp.GetHashCode() ^ OverallComp.GetHashCode() ^ CommunicationComp.GetHashCode() ^ CourtesyComp.GetHashCode() ^ ResponsivenessComp.GetHashCode() ^ InterviewDate.GetHashCode() ^ SampleDate.GetHashCode() ^ LoadDate.GetHashCode() ^ SurveyRound.GetHashCode() ^ RegionCode.GetHashCode() ^ WesId.GetHashCode() ^ SurveyOutcome.GetHashCode() ^ q1.GetHashCode() ^ q2.GetHashCode() ^ q3.GetHashCode() ^ q4.GetHashCode() ^ q5.GetHashCode() ^ q6.GetHashCode() ^ q7.GetHashCode() ^ q8.GetHashCode() ^ q9.GetHashCode() ^ q10.GetHashCode() ^ q11.GetHashCode() ^ q12.GetHashCode() ^ q13.GetHashCode() ^ q14.GetHashCode() ^ q15.GetHashCode() ^ q16.GetHashCode() ^ q17.GetHashCode() ^ q18.GetHashCode() ^ q19.GetHashCode() ^ q20.GetHashCode() ^ SurveyQuarter.GetHashCode() ^ SurveyType.GetHashCode());
}
public override Boolean Check(Address @object)
{
return((CountryCode != null && RegionCode != null && SettlementCode != null && SettlementCode.Check(@object.Settlement.Code)) ||
(CountryCode != null && RegionCode != null && SettlementCode == null && RegionCode.Check(@object.Region.Code)) ||
(CountryCode != null && RegionCode == null && SettlementCode == null && CountryCode.Check(@object.Country.Code)) ||
(CountryCode == null && RegionCode == null && SettlementCode == null));
}
public static string GetDescription(this RegionCode regionCode)
{
return(regionCode.GetAttributeProperty <DescriptionAttribute, string>(attribute => attribute.Description));
}
/// <summary>
/// Creates a CultureAndRegionInfoBuilder object for the NCLDR culture
/// </summary>
/// <param name="cldrCultureName">The name of the CLDR culture from which to create the .NET culture</param>
/// <param name="dotNetCultureName">The name of the .NET custom culture to create</param>
/// <returns>A CultureAndRegionInfoBuilder object for the NCLDR culture</returns>
public static CultureAndRegionInfoBuilder CreateNCldrCultureAndRegionInfoBuilder(string cldrCultureName, string dotNetCultureName)
{
Culture culture = Culture.GetCulture(cldrCultureName);
CultureAndRegionModifiers cultureAndRegionModifiers =
culture.IsNeutralCulture ? CultureAndRegionModifiers.Neutral : CultureAndRegionModifiers.None;
CultureAndRegionInfoBuilder builder = new CultureAndRegionInfoBuilder(dotNetCultureName, cultureAndRegionModifiers);
CultureInfo parentCultureInfo = GetParentCultureInfo(culture);
builder.Parent = parentCultureInfo;
if (string.IsNullOrEmpty(culture.EnglishName))
{
builder.CultureEnglishName = culture.Identity.CultureName;
}
else
{
builder.CultureEnglishName = culture.EnglishName;
}
if (string.IsNullOrEmpty(culture.NativeName) && string.IsNullOrEmpty(culture.EnglishName))
{
builder.CultureNativeName = culture.Identity.CultureName;
}
else if (string.IsNullOrEmpty(culture.NativeName))
{
builder.CultureNativeName = culture.EnglishName;
}
else
{
builder.CultureNativeName = culture.NativeName;
}
builder.TwoLetterISOLanguageName = culture.Identity.Language.Id;
// CLDR does not have data for ThreeLetterISOLanguageName but one must be assigned for the culture to be valid
builder.ThreeLetterISOLanguageName = culture.Identity.Language.Id;
// CLDR does not have data for ThreeLetterWindowsLanguageName but one must be assigned for the culture to be valid
builder.ThreeLetterWindowsLanguageName = culture.Identity.Language.Id;
// The CultureAndRegionInfoBuilder requires dummy values for these properties
// even though there is no region or currency values
builder.RegionEnglishName = "xxx";
builder.RegionNativeName = "xxx";
builder.ThreeLetterISORegionName = "xxx";
builder.ThreeLetterWindowsRegionName = "xxx";
builder.TwoLetterISORegionName = "xx";
builder.ISOCurrencySymbol = "xx";
builder.CurrencyEnglishName = "xxx";
builder.CurrencyNativeName = "xxx";
if (culture.Identity.Region != null)
{
Region region = culture.Identity.Region;
builder.RegionEnglishName = region.EnglishName;
string regionNativeName = region.DisplayName(culture.Identity.Language.Id);
if (string.IsNullOrEmpty(regionNativeName))
{
builder.RegionNativeName = region.EnglishName;
}
else
{
builder.RegionNativeName = regionNativeName;
}
RegionCode regionCode = RegionExtensions.GetRegionCode(region.Id);
if (regionCode != null && regionCode.Alpha3 != null)
{
builder.ThreeLetterISORegionName = regionCode.Alpha3;
}
else
{
builder.ThreeLetterISORegionName = region.Id;
}
// CLDR does not have data for ThreeLetterWindowsRegionName but one must be assigned for the culture to be valid
builder.ThreeLetterWindowsRegionName = region.Id;
builder.TwoLetterISORegionName = region.Id;
builder.IsMetric = RegionExtensions.GetMeasurementSystem(region.Id).IsMetric;
}
else
{
builder.IsMetric = RegionExtensions.GetMeasurementSystem(NCldr.RegionIdForTheWorld).IsMetric;
}
// CLDR does not have data for KeyboardLayoutId or GeoId
builder.IetfLanguageTag = cldrCultureName;
builder.GregorianDateTimeFormat = CreateDateTimeFormatInfo(culture);
builder.AvailableCalendars = GetAvailableCalendars(culture);
builder.NumberFormat = CreateNumberFormatInfo(culture);
if (culture.Numbers != null &&
culture.Numbers.CurrencyDisplayNameSets != null &&
culture.Numbers.CurrentCurrencyPeriod != null)
{
string currencyName = culture.Numbers.CurrentCurrencyPeriod.Id;
if (!string.IsNullOrEmpty(currencyName))
{
builder.ISOCurrencySymbol = currencyName;
builder.CurrencyEnglishName = CultureExtensions.GetCurrencyDisplayName(currencyName, "en");
string currencyNativeName = CultureExtensions.GetCurrencyDisplayName(currencyName, culture.Identity.Language.Id);
builder.CurrencyNativeName = currencyNativeName == null ? builder.CurrencyEnglishName : currencyNativeName;
}
}
builder.TextInfo = parentCultureInfo.TextInfo;
builder.CompareInfo = parentCultureInfo.CompareInfo;
return(builder);
}
/// <summary>
/// Gets the region code's short name (e.g., <c>"A"</c>, <c>"B"</c>, <c>"C"</c>, <c>"Free"</c>).
/// </summary>
public static string GetName(this RegionCode regionCode)
{
return(string.Format("{0}", Enum.GetName(regionCode.GetType(), regionCode)));
}
/// <summary>
/// Gets the region code's long name (e.g., <c>"Region A"</c>, <c>"Region B"</c>, <c>"Region C"</c>, <c>"Region-free"</c>).
/// </summary>
public static string GetLongName(this RegionCode regionCode)
{
return(regionCode == RegionCode.Free
? "Region-free"
: string.Format("Region {0}", regionCode.GetName()));
}
public void SetRegion(RegionCode region)
{
DesiredRegionCode = (uint)region;
}
public static extern int GetDiscInfoEx(int index, StringBuilder discId, ref float size, StringBuilder discName, ref RegionCode regionCode);
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset.mid)
{
hashcode = (hashcode * 397) + Mid.GetHashCode();
}
if (__isset.userid)
{
hashcode = (hashcode * 397) + Userid.GetHashCode();
}
if (__isset.phone)
{
hashcode = (hashcode * 397) + Phone.GetHashCode();
}
if (__isset.email)
{
hashcode = (hashcode * 397) + Email.GetHashCode();
}
if (__isset.regionCode)
{
hashcode = (hashcode * 397) + RegionCode.GetHashCode();
}
if (__isset.displayName)
{
hashcode = (hashcode * 397) + DisplayName.GetHashCode();
}
if (__isset.phoneticName)
{
hashcode = (hashcode * 397) + PhoneticName.GetHashCode();
}
if (__isset.pictureStatus)
{
hashcode = (hashcode * 397) + PictureStatus.GetHashCode();
}
if (__isset.thumbnailUrl)
{
hashcode = (hashcode * 397) + ThumbnailUrl.GetHashCode();
}
if (__isset.statusMessage)
{
hashcode = (hashcode * 397) + StatusMessage.GetHashCode();
}
if (__isset.allowSearchByUserid)
{
hashcode = (hashcode * 397) + AllowSearchByUserid.GetHashCode();
}
if (__isset.allowSearchByEmail)
{
hashcode = (hashcode * 397) + AllowSearchByEmail.GetHashCode();
}
if (__isset.picturePath)
{
hashcode = (hashcode * 397) + PicturePath.GetHashCode();
}
if (__isset.musicProfile)
{
hashcode = (hashcode * 397) + MusicProfile.GetHashCode();
}
if (__isset.videoProfile)
{
hashcode = (hashcode * 397) + VideoProfile.GetHashCode();
}
}
return(hashcode);
}
/// <summary>
/// Returns true if ResponseGeocodingProperties instances are equal
/// </summary>
/// <param name="other">Instance of ResponseGeocodingProperties to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ResponseGeocodingProperties other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
Label == other.Label ||
Label != null &&
Label.Equals(other.Label)
) &&
(
Score == other.Score ||
Score.Equals(other.Score)
) &&
(
HouseNumber == other.HouseNumber ||
HouseNumber != null &&
HouseNumber.Equals(other.HouseNumber)
) &&
(
Street == other.Street ||
Street != null &&
Street.Equals(other.Street)
) &&
(
Region == other.Region ||
Region != null &&
Region.Equals(other.Region)
) &&
(
RegionCode == other.RegionCode ||
RegionCode != null &&
RegionCode.Equals(other.RegionCode)
) &&
(
Neighbourhood == other.Neighbourhood ||
Neighbourhood != null &&
Neighbourhood.Equals(other.Neighbourhood)
) &&
(
County == other.County ||
County != null &&
County.Equals(other.County)
) &&
(
Macroregion == other.Macroregion ||
Macroregion != null &&
Macroregion.Equals(other.Macroregion)
) &&
(
City == other.City ||
City != null &&
City.Equals(other.City)
) &&
(
Country == other.Country ||
Country != null &&
Country.Equals(other.Country)
) &&
(
CountryCode == other.CountryCode ||
CountryCode != null &&
CountryCode.Equals(other.CountryCode)
) &&
(
Continent == other.Continent ||
Continent != null &&
Continent.Equals(other.Continent)
) &&
(
Postcode == other.Postcode ||
Postcode != null &&
Postcode.Equals(other.Postcode)
) &&
(
Features == other.Features ||
Features != null &&
Features.Equals(other.Features)
));
}
public override int GetHashCode() => RegionCode.GetHashCode();
/// <summary>
/// Set Fixed Frequency Channel
/// All region can be used to set a fixed channel
/// </summary>
/// <param name="prof">Region Code</param>
/// <param name="channel">Channel number start from zero, you can get the available channels
/// from CSLibrary.HighLevelInterface.AvailableFrequencyTable(CSLibrary.Constants.RegionCode)</param>
public Result SetFixedChannel(RegionCode prof = RegionCode.CURRENT, uint channel = 0)
{
if (m_save_fixed_channel == true && m_save_region_code == prof && m_save_freq_channel == channel)
{
if (currentInventoryFreqRevIndex == null)
{
currentInventoryFreqRevIndex = new uint[1] {
channel
}
}
;
return(Result.OK);
}
uint Reg0x700 = 0;
//DEBUG_WriteLine(DEBUGLEVEL.API, "HighLevelInterface.SetFixedChannel(RegionCode prof, uint channel, LBT LBTcfg)");
if (IsHoppingChannelOnly)
{
return(Result.INVALID_PARAMETER);
}
if (!GetActiveRegionCode().Contains(prof))
{
return(Result.INVALID_PARAMETER);
}
// disable agile mode
MacReadRegister(MACREGISTER.HST_ANT_CYCLES /*0x700*/, ref Reg0x700);
Reg0x700 &= ~0x01000000U;
MacWriteRegister(MACREGISTER.HST_ANT_CYCLES /*0x700*/, Reg0x700);
//AGAIN:
//try
{
//Result status = Result.OK;
uint TotalCnt = FreqChnCnt(prof);
uint[] freqTable = FreqTable(prof);
uint i = 0;
// Check Parameters
if (!FreqChnWithinRange(channel, prof) || freqTable == null)
{
return(Result.INVALID_PARAMETER);
}
int Index = FreqSortedIdxTbls(prof, channel);
if (Index < 0)
{
return(Result.INVALID_PARAMETER);
}
//Enable channel
SetFrequencyBand(0, BandState.ENABLE, freqTable[Index], GetPllcc(prof));
//ThrowException(SetFrequencyBand((uint)Index, BandState.ENABLE, freqTable[Index], GetPllcc(prof)));
//ThrowException(SetFrequencyBand(0, BandState.ENABLE, freqTable[Index]));
i = 1;
//Disable channels
for (uint j = i; j < MAXFRECHANNEL; j++)
{
SetFrequencyBand(j, BandState.DISABLE, 0, 0);
}
SetRadioLBT(LBT.OFF);
m_save_region_code = prof;
m_save_freq_channel = channel;
m_save_fixed_channel = true;
m_save_agile_channel = false;
m_save_selected_freq = GetAvailableFrequencyTable(prof)[channel];
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (Label != null)
{
hashCode = hashCode * 59 + Label.GetHashCode();
}
hashCode = hashCode * 59 + Score.GetHashCode();
if (HouseNumber != null)
{
hashCode = hashCode * 59 + HouseNumber.GetHashCode();
}
if (Street != null)
{
hashCode = hashCode * 59 + Street.GetHashCode();
}
if (Region != null)
{
hashCode = hashCode * 59 + Region.GetHashCode();
}
if (RegionCode != null)
{
hashCode = hashCode * 59 + RegionCode.GetHashCode();
}
if (Neighbourhood != null)
{
hashCode = hashCode * 59 + Neighbourhood.GetHashCode();
}
if (County != null)
{
hashCode = hashCode * 59 + County.GetHashCode();
}
if (Macroregion != null)
{
hashCode = hashCode * 59 + Macroregion.GetHashCode();
}
if (City != null)
{
hashCode = hashCode * 59 + City.GetHashCode();
}
if (Country != null)
{
hashCode = hashCode * 59 + Country.GetHashCode();
}
if (CountryCode != null)
{
hashCode = hashCode * 59 + CountryCode.GetHashCode();
}
if (Continent != null)
{
hashCode = hashCode * 59 + Continent.GetHashCode();
}
if (Postcode != null)
{
hashCode = hashCode * 59 + Postcode.GetHashCode();
}
if (Features != null)
{
hashCode = hashCode * 59 + Features.GetHashCode();
}
return(hashCode);
}
}
public override String ToString()
{
return(RegionCode.ToString());
}
/// <summary>
/// Returns public Region by RegionCode
/// </summary>
public static Region ByCode(RegionCode code)
{
switch (code)
{
case RegionCode.M001: return(M001Cache.Instance);
case RegionCode.M002: return(M002Cache.Instance);
case RegionCode.M003: return(M003Cache.Instance);
case RegionCode.M005: return(M005Cache.Instance);
case RegionCode.M009: return(M009Cache.Instance);
case RegionCode.M011: return(M011Cache.Instance);
case RegionCode.M013: return(M013Cache.Instance);
case RegionCode.M014: return(M014Cache.Instance);
case RegionCode.M015: return(M015Cache.Instance);
case RegionCode.M017: return(M017Cache.Instance);
case RegionCode.M018: return(M018Cache.Instance);
case RegionCode.M019: return(M019Cache.Instance);
case RegionCode.M021: return(M021Cache.Instance);
case RegionCode.M029: return(M029Cache.Instance);
case RegionCode.M030: return(M030Cache.Instance);
case RegionCode.M034: return(M034Cache.Instance);
case RegionCode.M035: return(M035Cache.Instance);
case RegionCode.M039: return(M039Cache.Instance);
case RegionCode.M053: return(M053Cache.Instance);
case RegionCode.M054: return(M054Cache.Instance);
case RegionCode.M057: return(M057Cache.Instance);
case RegionCode.M061: return(M061Cache.Instance);
case RegionCode.M142: return(M142Cache.Instance);
case RegionCode.M143: return(M143Cache.Instance);
case RegionCode.M145: return(M145Cache.Instance);
case RegionCode.M150: return(M150Cache.Instance);
case RegionCode.M151: return(M151Cache.Instance);
case RegionCode.M154: return(M154Cache.Instance);
case RegionCode.M155: return(M155Cache.Instance);
case RegionCode.M202: return(M202Cache.Instance);
case RegionCode.M419: return(M419Cache.Instance);
case RegionCode.AC: return(ACCache.Instance);
case RegionCode.AD: return(ADCache.Instance);
case RegionCode.AE: return(AECache.Instance);
case RegionCode.AF: return(AFCache.Instance);
case RegionCode.AG: return(AGCache.Instance);
case RegionCode.AI: return(AICache.Instance);
case RegionCode.AL: return(ALCache.Instance);
case RegionCode.AM: return(AMCache.Instance);
case RegionCode.AN: return(ANCache.Instance);
case RegionCode.AO: return(AOCache.Instance);
case RegionCode.AQ: return(AQCache.Instance);
case RegionCode.AR: return(ARCache.Instance);
case RegionCode.AS: return(ASCache.Instance);
case RegionCode.AT: return(ATCache.Instance);
case RegionCode.AU: return(AUCache.Instance);
case RegionCode.AW: return(AWCache.Instance);
case RegionCode.AX: return(AXCache.Instance);
case RegionCode.AZ: return(AZCache.Instance);
case RegionCode.BA: return(BACache.Instance);
case RegionCode.BB: return(BBCache.Instance);
case RegionCode.BD: return(BDCache.Instance);
case RegionCode.BE: return(BECache.Instance);
case RegionCode.BF: return(BFCache.Instance);
case RegionCode.BG: return(BGCache.Instance);
case RegionCode.BH: return(BHCache.Instance);
case RegionCode.BI: return(BICache.Instance);
case RegionCode.BJ: return(BJCache.Instance);
case RegionCode.BL: return(BLCache.Instance);
case RegionCode.BM: return(BMCache.Instance);
case RegionCode.BN: return(BNCache.Instance);
case RegionCode.BO: return(BOCache.Instance);
case RegionCode.BQ: return(BQCache.Instance);
case RegionCode.BR: return(BRCache.Instance);
case RegionCode.BS: return(BSCache.Instance);
case RegionCode.BT: return(BTCache.Instance);
case RegionCode.BU: return(BUCache.Instance);
case RegionCode.BV: return(BVCache.Instance);
case RegionCode.BW: return(BWCache.Instance);
case RegionCode.BY: return(BYCache.Instance);
case RegionCode.BZ: return(BZCache.Instance);
case RegionCode.CA: return(CACache.Instance);
case RegionCode.CC: return(CCCache.Instance);
case RegionCode.CD: return(CDCache.Instance);
case RegionCode.CF: return(CFCache.Instance);
case RegionCode.CG: return(CGCache.Instance);
case RegionCode.CH: return(CHCache.Instance);
case RegionCode.CI: return(CICache.Instance);
case RegionCode.CK: return(CKCache.Instance);
case RegionCode.CL: return(CLCache.Instance);
case RegionCode.CM: return(CMCache.Instance);
case RegionCode.CN: return(CNCache.Instance);
case RegionCode.CO: return(COCache.Instance);
case RegionCode.CP: return(CPCache.Instance);
case RegionCode.CR: return(CRCache.Instance);
case RegionCode.CS: return(CSCache.Instance);
case RegionCode.CU: return(CUCache.Instance);
case RegionCode.CV: return(CVCache.Instance);
case RegionCode.CW: return(CWCache.Instance);
case RegionCode.CX: return(CXCache.Instance);
case RegionCode.CY: return(CYCache.Instance);
case RegionCode.CZ: return(CZCache.Instance);
case RegionCode.DD: return(DDCache.Instance);
case RegionCode.DE: return(DECache.Instance);
case RegionCode.DG: return(DGCache.Instance);
case RegionCode.DJ: return(DJCache.Instance);
case RegionCode.DK: return(DKCache.Instance);
case RegionCode.DM: return(DMCache.Instance);
case RegionCode.DO: return(DOCache.Instance);
case RegionCode.DZ: return(DZCache.Instance);
case RegionCode.EA: return(EACache.Instance);
case RegionCode.EC: return(ECCache.Instance);
case RegionCode.EE: return(EECache.Instance);
case RegionCode.EG: return(EGCache.Instance);
case RegionCode.EH: return(EHCache.Instance);
case RegionCode.ER: return(ERCache.Instance);
case RegionCode.ES: return(ESCache.Instance);
case RegionCode.ET: return(ETCache.Instance);
case RegionCode.EU: return(EUCache.Instance);
case RegionCode.EZ: return(EZCache.Instance);
case RegionCode.FI: return(FICache.Instance);
case RegionCode.FJ: return(FJCache.Instance);
case RegionCode.FK: return(FKCache.Instance);
case RegionCode.FM: return(FMCache.Instance);
case RegionCode.FO: return(FOCache.Instance);
case RegionCode.FR: return(FRCache.Instance);
case RegionCode.FX: return(FXCache.Instance);
case RegionCode.GA: return(GACache.Instance);
case RegionCode.GB: return(GBCache.Instance);
case RegionCode.GD: return(GDCache.Instance);
case RegionCode.GE: return(GECache.Instance);
case RegionCode.GF: return(GFCache.Instance);
case RegionCode.GG: return(GGCache.Instance);
case RegionCode.GH: return(GHCache.Instance);
case RegionCode.GI: return(GICache.Instance);
case RegionCode.GL: return(GLCache.Instance);
case RegionCode.GM: return(GMCache.Instance);
case RegionCode.GN: return(GNCache.Instance);
case RegionCode.GP: return(GPCache.Instance);
case RegionCode.GQ: return(GQCache.Instance);
case RegionCode.GR: return(GRCache.Instance);
case RegionCode.GS: return(GSCache.Instance);
case RegionCode.GT: return(GTCache.Instance);
case RegionCode.GU: return(GUCache.Instance);
case RegionCode.GW: return(GWCache.Instance);
case RegionCode.GY: return(GYCache.Instance);
case RegionCode.HK: return(HKCache.Instance);
case RegionCode.HM: return(HMCache.Instance);
case RegionCode.HN: return(HNCache.Instance);
case RegionCode.HR: return(HRCache.Instance);
case RegionCode.HT: return(HTCache.Instance);
case RegionCode.HU: return(HUCache.Instance);
case RegionCode.IC: return(ICCache.Instance);
case RegionCode.ID: return(IDCache.Instance);
case RegionCode.IE: return(IECache.Instance);
case RegionCode.IL: return(ILCache.Instance);
case RegionCode.IM: return(IMCache.Instance);
case RegionCode.IN: return(INCache.Instance);
case RegionCode.IO: return(IOCache.Instance);
case RegionCode.IQ: return(IQCache.Instance);
case RegionCode.IR: return(IRCache.Instance);
case RegionCode.IS: return(ISCache.Instance);
case RegionCode.IT: return(ITCache.Instance);
case RegionCode.JE: return(JECache.Instance);
case RegionCode.JM: return(JMCache.Instance);
case RegionCode.JO: return(JOCache.Instance);
case RegionCode.JP: return(JPCache.Instance);
case RegionCode.KE: return(KECache.Instance);
case RegionCode.KG: return(KGCache.Instance);
case RegionCode.KH: return(KHCache.Instance);
case RegionCode.KI: return(KICache.Instance);
case RegionCode.KM: return(KMCache.Instance);
case RegionCode.KN: return(KNCache.Instance);
case RegionCode.KP: return(KPCache.Instance);
case RegionCode.KR: return(KRCache.Instance);
case RegionCode.KW: return(KWCache.Instance);
case RegionCode.KY: return(KYCache.Instance);
case RegionCode.KZ: return(KZCache.Instance);
case RegionCode.LA: return(LACache.Instance);
case RegionCode.LB: return(LBCache.Instance);
case RegionCode.LC: return(LCCache.Instance);
case RegionCode.LI: return(LICache.Instance);
case RegionCode.LK: return(LKCache.Instance);
case RegionCode.LR: return(LRCache.Instance);
case RegionCode.LS: return(LSCache.Instance);
case RegionCode.LT: return(LTCache.Instance);
case RegionCode.LU: return(LUCache.Instance);
case RegionCode.LV: return(LVCache.Instance);
case RegionCode.LY: return(LYCache.Instance);
case RegionCode.MA: return(MACache.Instance);
case RegionCode.MC: return(MCCache.Instance);
case RegionCode.MD: return(MDCache.Instance);
case RegionCode.ME: return(MECache.Instance);
case RegionCode.MF: return(MFCache.Instance);
case RegionCode.MG: return(MGCache.Instance);
case RegionCode.MH: return(MHCache.Instance);
case RegionCode.MK: return(MKCache.Instance);
case RegionCode.ML: return(MLCache.Instance);
case RegionCode.MM: return(MMCache.Instance);
case RegionCode.MN: return(MNCache.Instance);
case RegionCode.MO: return(MOCache.Instance);
case RegionCode.MP: return(MPCache.Instance);
case RegionCode.MQ: return(MQCache.Instance);
case RegionCode.MR: return(MRCache.Instance);
case RegionCode.MS: return(MSCache.Instance);
case RegionCode.MT: return(MTCache.Instance);
case RegionCode.MU: return(MUCache.Instance);
case RegionCode.MV: return(MVCache.Instance);
case RegionCode.MW: return(MWCache.Instance);
case RegionCode.MX: return(MXCache.Instance);
case RegionCode.MY: return(MYCache.Instance);
case RegionCode.MZ: return(MZCache.Instance);
case RegionCode.NA: return(NACache.Instance);
case RegionCode.NC: return(NCCache.Instance);
case RegionCode.NE: return(NECache.Instance);
case RegionCode.NF: return(NFCache.Instance);
case RegionCode.NG: return(NGCache.Instance);
case RegionCode.NI: return(NICache.Instance);
case RegionCode.NL: return(NLCache.Instance);
case RegionCode.NO: return(NOCache.Instance);
case RegionCode.NP: return(NPCache.Instance);
case RegionCode.NR: return(NRCache.Instance);
case RegionCode.NT: return(NTCache.Instance);
case RegionCode.NU: return(NUCache.Instance);
case RegionCode.NZ: return(NZCache.Instance);
case RegionCode.OM: return(OMCache.Instance);
case RegionCode.PA: return(PACache.Instance);
case RegionCode.PE: return(PECache.Instance);
case RegionCode.PF: return(PFCache.Instance);
case RegionCode.PG: return(PGCache.Instance);
case RegionCode.PH: return(PHCache.Instance);
case RegionCode.PK: return(PKCache.Instance);
case RegionCode.PL: return(PLCache.Instance);
case RegionCode.PM: return(PMCache.Instance);
case RegionCode.PN: return(PNCache.Instance);
case RegionCode.PR: return(PRCache.Instance);
case RegionCode.PS: return(PSCache.Instance);
case RegionCode.PT: return(PTCache.Instance);
case RegionCode.PW: return(PWCache.Instance);
case RegionCode.PY: return(PYCache.Instance);
case RegionCode.QA: return(QACache.Instance);
case RegionCode.RE: return(RECache.Instance);
case RegionCode.RO: return(ROCache.Instance);
case RegionCode.RS: return(RSCache.Instance);
case RegionCode.RU: return(RUCache.Instance);
case RegionCode.RW: return(RWCache.Instance);
case RegionCode.SA: return(SACache.Instance);
case RegionCode.SB: return(SBCache.Instance);
case RegionCode.SC: return(SCCache.Instance);
case RegionCode.SD: return(SDCache.Instance);
case RegionCode.SE: return(SECache.Instance);
case RegionCode.SG: return(SGCache.Instance);
case RegionCode.SH: return(SHCache.Instance);
case RegionCode.SI: return(SICache.Instance);
case RegionCode.SJ: return(SJCache.Instance);
case RegionCode.SK: return(SKCache.Instance);
case RegionCode.SL: return(SLCache.Instance);
case RegionCode.SM: return(SMCache.Instance);
case RegionCode.SN: return(SNCache.Instance);
case RegionCode.SO: return(SOCache.Instance);
case RegionCode.SR: return(SRCache.Instance);
case RegionCode.SS: return(SSCache.Instance);
case RegionCode.ST: return(STCache.Instance);
case RegionCode.SU: return(SUCache.Instance);
case RegionCode.SV: return(SVCache.Instance);
case RegionCode.SX: return(SXCache.Instance);
case RegionCode.SY: return(SYCache.Instance);
case RegionCode.SZ: return(SZCache.Instance);
case RegionCode.TA: return(TACache.Instance);
case RegionCode.TC: return(TCCache.Instance);
case RegionCode.TD: return(TDCache.Instance);
case RegionCode.TF: return(TFCache.Instance);
case RegionCode.TG: return(TGCache.Instance);
case RegionCode.TH: return(THCache.Instance);
case RegionCode.TJ: return(TJCache.Instance);
case RegionCode.TK: return(TKCache.Instance);
case RegionCode.TL: return(TLCache.Instance);
case RegionCode.TM: return(TMCache.Instance);
case RegionCode.TN: return(TNCache.Instance);
case RegionCode.TO: return(TOCache.Instance);
case RegionCode.TP: return(TPCache.Instance);
case RegionCode.TR: return(TRCache.Instance);
case RegionCode.TT: return(TTCache.Instance);
case RegionCode.TV: return(TVCache.Instance);
case RegionCode.TW: return(TWCache.Instance);
case RegionCode.TZ: return(TZCache.Instance);
case RegionCode.UA: return(UACache.Instance);
case RegionCode.UG: return(UGCache.Instance);
case RegionCode.UM: return(UMCache.Instance);
case RegionCode.UN: return(UNCache.Instance);
case RegionCode.US: return(USCache.Instance);
case RegionCode.UY: return(UYCache.Instance);
case RegionCode.UZ: return(UZCache.Instance);
case RegionCode.VA: return(VACache.Instance);
case RegionCode.VC: return(VCCache.Instance);
case RegionCode.VE: return(VECache.Instance);
case RegionCode.VG: return(VGCache.Instance);
case RegionCode.VI: return(VICache.Instance);
case RegionCode.VN: return(VNCache.Instance);
case RegionCode.VU: return(VUCache.Instance);
case RegionCode.WF: return(WFCache.Instance);
case RegionCode.WS: return(WSCache.Instance);
case RegionCode.YD: return(YDCache.Instance);
case RegionCode.YE: return(YECache.Instance);
case RegionCode.YT: return(YTCache.Instance);
case RegionCode.YU: return(YUCache.Instance);
case RegionCode.ZA: return(ZACache.Instance);
case RegionCode.ZM: return(ZMCache.Instance);
case RegionCode.ZR: return(ZRCache.Instance);
case RegionCode.ZW: return(ZWCache.Instance);
default: throw new ArgumentException(nameof(code), $"the code '{code}' does not correspond to the public region");
}
}
private Region(string tag, RegionCode enumCode, bool deprecated)
{
_tag = tag;
EnumCode = enumCode;
Deprecated = deprecated;
}
public static AuthenticatorRegion Factory(RegionCode regionType)
{
if (regionType == RegionCode.NorthAmerica || regionType == RegionCode.Europe)
{
AuthenticatorRegion region = new AuthenticatorRegion();
region.RegionType = regionType;
return region;
}
return null;
}
