/// <summary>
/// Initializes a new instance of the <see cref="CacheBuilder{T}"/> using.
/// </summary>
public CacheBuilder()
{
expiry_after_access_nanos_ = kUnsetInt;
expiry_after_write_nanos_ = kUnsetInt;
refresh_nanos_ = kUnsetInt;
value_strench_ = StrengthType.Strong;
}
/// <summary>
/// The StrengthToString static conversion function
/// allows a previously stored signal strength
/// enumeration value to be converted into its string
/// representation.
/// </summary>
/// <param name="st">
/// One of the SignalStrength enumeration values.
/// </param>
/// <returns>
/// String: "No Signal", "Very Low", "Low", "Good",
/// "Very Good", "Excellent", or
/// "Not a wireless adapter".
/// </returns>
public static String StrengthToString(StrengthType st)
{
string retval = string.Empty;
switch (st)
{
case StrengthType.NotAWirelessAdapter:
return("Not a wireless adapter");
case StrengthType.VeryLow:
return("Very Low");
case StrengthType.Low:
return("Low");
case StrengthType.Good:
return("Good");
case StrengthType.VeryGood:
return("Very Good");
case StrengthType.Excellent:
return("Excellent");
}
// If we don't catch the value above, empty is
// probably the best string to return.
return(retval);
}
private void SignalWatcherProc(object o)
{
try
{
if ((m_wzc == null) || (m_wzc.SignalStrength == null))
{
CurrentSignalStrength = StrengthType.NoSignal;
Debug.WriteLine("No Signal");
}
else
{
if (m_wzc.AssociatedAccessPoint == null)
{
Debug.WriteLine("No Signal (not connected)");
}
else
{
CurrentSignalStrength = m_wzc.SignalStrength.Strength;
Debug.WriteLine("Signal " + CurrentSignalStrength.ToString());
}
}
}
catch
{
CurrentSignalStrength = StrengthType.NoSignal;
Debug.WriteLine("No Signal (error)");
}
}
public AdHocAccessPoint(AccessPoint ap)
{
channel = ap.Channel;
macAddress = ap.PhysicalAddress.GetAddressBytes();
name = ap.Name;
privacy = ap.Privacy;
signalStrengthInDecibels = ap.SignalStrength.Decibels;
signalStrengthQuality = ap.SignalStrength.Strength;
supportedRates = ap.SupportedRates;
}
public async Task <string> Insert_BrandDoseTemplate(BrandDoseTemplateCreateVM vm, int userId)
{
try
{
//## First get the Strength id- read the list from Cache- don't go to DB.
var strengthTypeList = _cacheService.GetCacheValue <List <StrengthType> >(CacheKey.StrengthTypes);
var strengthType = strengthTypeList.FirstOrDefault(s => s.Name.Equals(vm.StrengthTypeText)); //## Use the Text to find the id, ie: '10 mg' = Id:2
if (strengthType is null)
{
//## Something peculiar strength may be, ie: "199 mg"--> insert it in the DB
strengthType = new StrengthType()
{
Name = vm.StrengthTypeText
};
await _context.StrengthTypes.AddAsync(strengthType);
await _context.SaveChangesAsync();
}
string teamplateName = CreateTemplateName(vm);
BrandDoseTemplate doseTemplate = new BrandDoseTemplate()
{
DrugBrandId = vm.DrugBrandId,
ModeOfDeliveryId = vm.ModeOfDeliveryId,
StrengthTypeId = strengthType.Id,
Dose = vm.Dose,
Frequency = vm.Frequency,
IntakePatternId = vm.IntakePatternId,
Duration = vm.Duration,
CreatedBy = userId,
DateCreated = DateTime.Now,
TemplateText = teamplateName
};
await _context.BrandDoseTemplates.AddAsync(doseTemplate);
await _context.SaveChangesAsync();
//## Add this new BrandDoseTemplate to the Cache- so others can see it immediately
UpdateBrandDoseTemplateIn_Cache(doseTemplate);
string result = $"{doseTemplate.Id};{teamplateName}"; //## Combine the Id of newly inserted Template and the TemplateTExt- to add to the Dropdown- on Success
return(result);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return("error");
//throw;
}
}
public static int StrengthMode(StrengthType Type)
{
return(Type switch
{
StrengthType.VeryWeak => 20,
StrengthType.Weak => 40,
StrengthType.Medium => 60,
StrengthType.Strong => 80,
StrengthType.VeryStrong => 100,
_ => 0,
});
/// <summary>
/// Creates a <see cref="IValueReference{T}"/> for the specified
/// value according to the given strength type.
/// </summary>
public static IValueReference <T> ReferenceValue <T>(
LoadingCache <T> .CacheEntry <T> entry, T value,
StrengthType strength_type)
{
switch (strength_type)
{
case StrengthType.Strong:
return(new StrongValueReference <T>(value));
case StrengthType.Soft:
case StrengthType.Weak:
default:
throw new NotImplementedException("Soft and weak values are not implemented.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadingCache{T}"/> class
/// by using the specified cache provider and builder.
/// </summary>
/// <param name="provider">
/// A <see cref="ICacheProvider"/> that is used to cache object.
/// </param>
/// <param name="builder">
/// A <see cref="CacheBuilder{T}"/> object that contains information about
/// the cache configuration.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="provider"/> or <paramref name="builder"/> are
/// <c>null</c>.
/// </exception>
public LoadingCache(ICacheProvider provider, CacheBuilder <T> builder)
{
if (provider == null || builder == null)
{
Thrower.ThrowArgumentNullException(provider == null
? ExceptionArgument.provider
: ExceptionArgument.builder);
}
cache_provider_ = provider;
cache_guid_ = Guid.NewGuid().ToString("N");
expire_after_access_nanos_ = builder.ExpiryAfterAccessNanos;
expire_after_write_nanos_ = builder.ExpiryAfterWriteNanos;
refresh_nanos_ = builder.RefreshNanos;
strength_type_ = builder.ValueStrength;
mutex_ = new object();
t_is_value_type_ = typeof(T).IsValueType;
default_cache_loader_ =
CacheLoader <T> .From(delegate { throw new NotSupportedException(); });
}
/// <summary>
/// The DBToString static conversion function allows a
/// signal strength value in dB previously retrieved
/// to be converted into the string representation of
/// its relative signal strength.
/// </summary>
/// <param name="db">
/// Signal strength in dB.
/// </param>
/// <returns>
/// String: "No Signal", "Very Low", "Low", "Good",
/// "Very Good", "Excellent", or
/// "Not a wireless adapter".
/// </returns>
public static String DBToString(int db)
{
StrengthType st = DBToStrength(db);
return(StrengthToString(st));
}
internal SignalEventArgs(StrengthType strength)
{
Strength = strength;
}
CacheBuilder <T> SetValueStrench(StrengthType strength_type)
{
value_strench_ = strength_type;
return(this);
}
/// <summary>
/// While adding new RSSI value
/// 1. If RSSI queue is full, dqueue the first element
/// 2. Update time of contact
/// </summary>
/// <param name="val"></param>
/// <param name="type"></param>
public void addRssi(int val, StrengthType type)
{
if(rssiValueHistory.Count >=queueSize)
{
rssiValueHistory.Dequeue();
rssiQualityHistory.Dequeue();
}
rssiValueHistory.Enqueue(val);
rssiQualityHistory.Enqueue(type);
if (type != StrengthType.NoSignal)
TimeOfContact += OppCommHandler.DiscoveryInterval;
else
TimeOfContact = 0;
}
/// <summary>
/// The StrengthToString static conversion function
/// allows a previously stored signal strength
/// enumeration value to be converted into its string
/// representation.
/// </summary>
/// <param name="st">
/// One of the SignalStrength enumeration values.
/// </param>
/// <returns>
/// String: "No Signal", "Very Low", "Low", "Good",
/// "Very Good", "Excellent", or
/// "Not a wireless adapter".
/// </returns>
public static String StrengthToString( StrengthType st )
{
string retval = string.Empty;
switch( st )
{
case StrengthType.NotAWirelessAdapter:
return "Not a wireless adapter";
case StrengthType.VeryLow:
return "Very Low";
case StrengthType.Low:
return "Low";
case StrengthType.Good:
return "Good";
case StrengthType.VeryGood:
return "Very Good";
case StrengthType.Excellent:
return "Excellent";
}
// If we don't catch the value above, empty is
// probably the best string to return.
return retval;
}
