/// <summary>
/// Construye un nuevo formateador de campos de mensajes cuyos
/// datos son de tipo cadena de caracteres.
/// </summary>
/// <param name="fieldNumber">
/// Es el número de campo del mensaje que el formateador es capaz
/// de formatear.
/// </param>
/// <param name="lengthManager">
/// Es el objeto que administra el largo de los datos del campo.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del campo.
/// </param>
/// <param name="padding">
/// Es el objeto capaz de rellenar los datos del campo.
/// </param>
/// <param name="validator">
/// Es el objeto capaz de validar los datos del campo.
/// </param>
/// <param name="valueFormatter">
/// Es el objeto capaz de formatear/analizar los datos del campo.
/// </param>
/// <param name="description">
/// Es la descripción del campo.
/// </param>
public StringFieldFormatter(int fieldNumber, LengthManager lengthManager,
IStringEncoder encoder, IStringPadding padding, IStringValidator validator,
IStringFieldValueFormatter valueFormatter, string description) :
base(fieldNumber, description)
{
if (lengthManager == null)
{
throw new ArgumentNullException("lengthManager");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
_lengthManager = lengthManager;
_encoder = encoder;
_validator = validator;
_valueFormatter = valueFormatter;
if ((padding == null) && (lengthManager is FixedLengthManager))
{
_padding = SpacePaddingRight.GetInstance(false);
}
else
{
_padding = padding;
}
}
/// <summary>
/// Construye un nuevo formateador de cabezales de mensajes cuyos
/// datos son de tipo cadena de caracteres.
/// </summary>
/// <param name="lengthManager">
/// Es el objeto que administra el largo de los datos del cabezal.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del cabezal.
/// </param>
/// <param name="padding">
/// Es el objeto capaz de rellenar los datos del cabezal.
/// </param>
public StringMessageHeaderFormatter(LengthManager lengthManager,
IStringEncoder encoder, IStringPadding padding) : base()
{
if (lengthManager == null)
{
throw new ArgumentNullException("lengthManager");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
_lengthManager = lengthManager;
_encoder = encoder;
if ((padding == null) && (lengthManager is FixedLengthManager))
{
_padding = SpacePaddingRight.GetInstance(false);
}
else
{
_padding = padding;
}
}
public void TestRandomStrings()
{
IStringEncoder[] encoders = new IStringEncoder[] {
new Metaphone(), new DoubleMetaphone(), new Soundex() /*, new RefinedSoundex()*/, new Caverphone2()
};
foreach (IStringEncoder e in encoders)
{
Analyzer a = Analyzer.NewAnonymous(createComponents: (fieldName, reader) =>
{
Tokenizer tokenizer = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
return(new TokenStreamComponents(tokenizer, new PhoneticFilter(tokenizer, e, false)));
});
CheckRandomData(Random(), a, 1000 * RANDOM_MULTIPLIER);
Analyzer b = Analyzer.NewAnonymous(createComponents: (fieldName, reader) =>
{
Tokenizer tokenizer = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
return(new TokenStreamComponents(tokenizer, new PhoneticFilter(tokenizer, e, false)));
});
CheckRandomData(Random(), b, 1000 * RANDOM_MULTIPLIER);
}
}
public SendRecoveryKeyCommandHandler(MonumentsDbContext dbContext,
IEmailSender emailSender,
IStringEncoder stringEncoder)
{
_dbContext = dbContext;
_emailSender = emailSender;
_stringEncoder = stringEncoder;
}
/// <summary>
/// Creates a <see cref="PhoneticFilter"/> with the specified encoder, and either
/// adding encoded forms as synonyms (<c>inject=true</c>) or
/// replacing them.
/// </summary>
public PhoneticFilter(TokenStream input, IStringEncoder encoder, bool inject)
: base(input)
{
this.encoder = encoder;
this.inject = inject;
this.termAtt = AddAttribute <ICharTermAttribute>();
this.posAtt = AddAttribute <IPositionIncrementAttribute>();
}
public ChangePasswordByRecoveryKeyCommandHandler(MonumentsDbContext dbContext,
IStringEncoder stringEncoder,
IPasswordEncryptor passwordEncryptor)
{
_dbContext = dbContext;
_stringEncoder = stringEncoder;
_passwordEncryptor = passwordEncryptor;
}
public virtual void TestEncodeEmpty()
{
IStringEncoder encoder = this.StringEncoder;
encoder.Encode("");
encoder.Encode(" ");
encoder.Encode("\t");
}
public Base64Encoder(
IOptions <Base64EncoderOptions> options,
ILogger <Base64Encoder> logger,
IStringEncoder stringEncoder)
{
this.options = options.Value ?? Base64EncoderOptions.Default;
this.logger = logger;
this.stringEncoder = stringEncoder;
}
static void assertAlgorithm(IStringEncoder encoder, bool inject, String input,
String[] expected)
{
Tokenizer tokenizer = new WhitespaceTokenizer(TEST_VERSION_CURRENT,
new StringReader(input));
PhoneticFilter filter = new PhoneticFilter(tokenizer, encoder, inject);
AssertTokenStreamContents(filter, expected);
}
public TextAssetDataProcessor(
IOptions <AssetsOptions> options,
IStringEncoder stringEncoder,
IVarsManager varsManager)
{
this.options = options.Value ?? AssetsOptions.Default;
this.stringEncoder = stringEncoder;
this.varsManager = varsManager;
}
public TestCaseContext()
{
Options = Mock.Of <IOptions <Base64EncoderOptions> >();
Logger = Mock.Of <ILogger <Base64Encoder> >();
StringEncoder = Mock.Of <IStringEncoder>();
Mock.Get(Options).Setup(
m => m.Value)
.Returns(Base64EncoderOptions.Default);
}
private KeyCreator(
IArgumentSerializer argumentSerializer,
IMemberInfoSerializer memberInfoSerializer,
IHashAlgorithm hashAlgorithm,
IStringEncoder stringEncoder)
{
_argumentSerializer = argumentSerializer;
_hashAlgorithm = hashAlgorithm;
_stringEncoder = stringEncoder;
_memberInfoSerializer = memberInfoSerializer;
}
public virtual void TestLocaleIndependence()
{
IStringEncoder encoder = this.StringEncoder;
string[]
data = { "I", "i", };
CultureInfo orig = CultureInfo.CurrentCulture;
CultureInfo[] locales = { new CultureInfo("en"), new CultureInfo("tr"), CultureInfo.CurrentCulture };
try
{
foreach (string element in data)
{
string @ref = null;
for (int j = 0; j < locales.Length; j++)
{
//Locale.setDefault(locales[j]);
#if NETSTANDARD
CultureInfo.CurrentCulture = locales[j];
#else
Thread.CurrentThread.CurrentCulture = locales[j];
#endif
if (j <= 0)
{
@ref = encoder.Encode(element);
}
else
{
string cur = null;
try
{
cur = encoder.Encode(element);
}
catch (Exception e)
{
Assert.Fail(CultureInfo.CurrentCulture.ToString() + ": " + e.Message);
}
Assert.AreEqual(@ref, cur, CultureInfo.CurrentCulture.ToString() + ": ");
}
}
}
}
finally
{
//Locale.setDefault(orig);
#if NETSTANDARD
CultureInfo.CurrentCulture = orig;
#else
Thread.CurrentThread.CurrentCulture = orig;
#endif
}
}
public virtual void TestEncodeNull()
{
IStringEncoder encoder = this.StringEncoder;
try
{
encoder.Encode(null);
}
#pragma warning disable 168
catch (/*Encoder*/ Exception ee)
#pragma warning restore 168
{
// An exception should be thrown
}
}
public ScriptHost(
IOptions <ScriptHostOptions> options,
ILogger <ScriptHost> logger,
ILogger <HellScriptContext> scriptLogger,
IStringEncoder stringEncoder,
ISessionManager sessionManager,
IServiceProvider serviceProvider)
{
this.options = options.Value ?? ScriptHostOptions.Default;
this.logger = logger;
this.scriptLogger = scriptLogger;
this.stringEncoder = stringEncoder;
this.sessionManager = sessionManager;
this.serviceProvider = serviceProvider;
}
public void TestEmptyTerm()
{
IStringEncoder[] encoders = new IStringEncoder[] {
new Metaphone(), new DoubleMetaphone(), new Soundex() /*, new RefinedSoundex()*/, new Caverphone2()
};
foreach (IStringEncoder e in encoders)
{
Analyzer a = Analyzer.NewAnonymous(createComponents: (fieldName, reader) =>
{
Tokenizer tokenizer = new KeywordTokenizer(reader);
return(new TokenStreamComponents(tokenizer, new PhoneticFilter(tokenizer, e, Random().nextBoolean())));
});
CheckOneTerm(a, "", "");
}
}
public AssetsManager(
IOptions <AssetsOptions> options,
ILogger <AssetsManager> logger,
IAssetDescriptorsCache assetDescriptorsCache,
IStringEncoder stringEncoder,
IBase64Encoder base64Encoder,
ITextAssetDataProcessor textAssetDataProcessor,
IAssetManagerDataService dataService)
{
this.options = options.Value ?? AssetsOptions.Default;
this.logger = logger;
this.assetDescriptorsCache = assetDescriptorsCache;
this.stringEncoder = stringEncoder;
this.base64Encoder = base64Encoder;
this.textAssetDataProcessor = textAssetDataProcessor;
this.dataService = dataService;
}
/// <summary>Must be thread-safe.</summary>
protected internal virtual IStringEncoder GetEncoder()
{
// Unfortunately, Commons-Codec doesn't offer any thread-safe guarantees so we must play it safe and instantiate
// every time. A simple benchmark showed this as negligible.
try
{
IStringEncoder encoder = (IStringEncoder)Activator.CreateInstance(clazz);
// Try to set the maxCodeLength
if (maxCodeLength != null && setMaxCodeLenMethod != null)
{
setMaxCodeLenMethod.Invoke(encoder, new object[] { maxCodeLength });
}
return(encoder);
}
catch (Exception e)
{
Exception t = (e is TargetInvocationException) ? e.InnerException : e;
throw new ArgumentException("Error initializing encoder: " + name + " / " + clazz, t);
}
}
public static IEnumerable <PropertyVm> GetPropertyVmsUsingReflection(IStringEncoder helper, object model, Type fallbackModelType)
{
var type = model != null?model.GetType() : fallbackModelType;
var typeVm = new PropertyVm(typeof(string), "__type")
{
DisplayName = "",
IsHidden = true,
Value = helper.WriteTypeToString(type)
};
yield return(typeVm);
var properties = type.GetProperties();
foreach (var property in properties)
{
if (properties.Any(p => p.Name + "_choices" == property.Name))
{
continue; //skip this is it is choice
}
var inputVm = new PropertyVm(model, property);
PropertyInfo choices = properties.SingleOrDefault(p => p.Name == property.Name + "_choices");
if (choices != null)
{
inputVm.Choices = (IEnumerable)choices.GetGetMethod().Invoke(model, null);
}
PropertyInfo suggestions = properties.SingleOrDefault(p => p.Name == property.Name + "_suggestions");
if (suggestions != null)
{
inputVm.Suggestions = (IEnumerable)suggestions.GetGetMethod().Invoke(model, null);
}
yield return(inputVm);
}
}
public static IEnumerable<PropertyVm> GetPropertyVmsUsingReflection(IStringEncoder helper, object model, Type fallbackModelType)
{
var type = model != null ? model.GetType() : fallbackModelType;
var typeVm = new PropertyVm(typeof(string), "__type")
{
DisplayName = "",
IsHidden = true,
Value = helper.WriteTypeToString(type)
};
yield return typeVm;
var properties = type.GetProperties();
foreach (var property in properties)
{
if (properties.Any(p => p.Name + "Choices" == property.Name))
{
continue; //skip this is it is choice
}
var inputVm = new PropertyVm(model, property);
PropertyInfo choices = properties.SingleOrDefault(p => p.Name == property.Name + "_choices");
if (choices != null)
{
inputVm.Choices = (IEnumerable)choices.GetGetMethod().Invoke(model, null);
}
PropertyInfo suggestions = properties.SingleOrDefault(p => p.Name == property.Name + "_suggestions");
if (suggestions != null)
{
inputVm.Suggestions = (IEnumerable)suggestions.GetGetMethod().Invoke(model, null);
}
yield return inputVm;
}
}
public LoaderedProgFsYaffsImageConstructor(IIndexHelper IndexHelper, IStringEncoder StringEncoder, IChecksumProvider ChecksumProvider)
: base(IndexHelper)
{
_stringEncoder = StringEncoder;
_checksumProvider = ChecksumProvider;
}
/// <summary>
/// Construye un nuevo formateador de campos de mensajes cuyos
/// datos son de tipo cadena de caracteres.
/// </summary>
/// <param name="fieldNumber">
/// Es el número de campo del mensaje que el formateador es capaz
/// de formatear.
/// </param>
/// <param name="lengthManager">
/// Es el objeto que administra el largo de los datos del campo.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del campo.
/// </param>
/// <param name="padding">
/// Es el objeto capaz de rellenar los datos del campo.
/// </param>
public StringFieldFormatter(int fieldNumber, LengthManager lengthManager,
IStringEncoder encoder, IStringPadding padding) :
this(fieldNumber, lengthManager, encoder, padding, null, null,
string.Empty)
{
}
/// <summary>
/// Construye un nuevo formateador de campos de mensajes cuyos
/// datos son de tipo cadena de caracteres.
/// </summary>
/// <param name="fieldNumber">
/// Es el número de campo del mensaje que el formateador es capaz
/// de formatear.
/// </param>
/// <param name="lengthManager">
/// Es el objeto que administra el largo de los datos del campo.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del campo.
/// </param>
/// <param name="description">
/// Es la descripción del campo.
/// </param>
public StringFieldFormatter(int fieldNumber, LengthManager lengthManager,
IStringEncoder encoder, string description) : this(fieldNumber,
lengthManager, encoder, null, null, null, description)
{
}
public static IEnumerable<PropertyVm> PropertiesFor(IStringEncoder helper, object model, Type fallbackModelType = null)
{
fallbackModelType = fallbackModelType ?? model.GetType();
return GetPropertyVms(helper, model, fallbackModelType);
}
public static IEnumerable <PropertyVm> PropertiesFor(IStringEncoder helper, object model, Type fallbackModelType = null)
{
fallbackModelType = fallbackModelType ?? model.GetType();
return(GetPropertyVms(helper, model, fallbackModelType));
}
/// <summary>
/// Construye un nuevo formateador de cabezales de mensajes cuyos
/// datos son de tipo cadena de caracteres.
/// </summary>
/// <param name="lengthManager">
/// Es el objeto que administra el largo de los datos del cabezal.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del cabezal.
/// </param>
public StringMessageHeaderFormatter(LengthManager lengthManager,
IStringEncoder encoder) :
this(lengthManager, encoder, null)
{
}
public CacheKeyProvider(IStringEncoder stringEncoder)
{
_stringEncoder = stringEncoder;
}
/// <summary>
/// Construye un nuevo formateador de campos de mensajes cuyos
/// datos son de tipo cadena de caracteres.
/// </summary>
/// <param name="fieldNumber">
/// Es el número de campo del mensaje que el formateador es capaz
/// de formatear.
/// </param>
/// <param name="lengthManager">
/// Es el objeto que administra el largo de los datos del campo.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del campo.
/// </param>
/// <param name="padding">
/// Es el objeto capaz de rellenar los datos del campo.
/// </param>
/// <param name="validator">
/// Es el objeto capaz de validar los datos del campo.
/// </param>
/// <param name="valueFormatter">
/// Es el objeto capaz de formatear/analizar los datos del campo.
/// </param>
public StringFieldFormatter(int fieldNumber, LengthManager lengthManager,
IStringEncoder encoder, IStringPadding padding, IStringValidator validator,
IStringFieldValueFormatter valueFormatter) : this(fieldNumber,
lengthManager, encoder, padding, validator, null, string.Empty)
{
}
public SoftwarePropertiesProvider(ModuleProject Project, IStringEncoder StringEncoder, IChecksumProvider ChecksumProvider)
{
_project = Project;
_stringEncoder = StringEncoder;
_checksumProvider = ChecksumProvider;
}
public void Setup()
{
_bytes = Encoding.UTF8.GetBytes("qwertyuiop1234567890asdfghjklzxcvbnm");
_base64 = new Base64StringEncoder();
_hexadecimal = new HexadecimalStringEncoder();
}
public PropertiesTableGenerator(IStringEncoder StringEncoder)
{
_stringEncoder = StringEncoder;
}
/// <summary>
/// Encodes the Strings and returns the number of characters in the two
/// encoded Strings that are the same.
/// <list type="bullet">
/// <item><description>
/// For Soundex, this return value ranges from 0 through 4: 0 indicates
/// little or no similarity, and 4 indicates strong similarity or identical
/// values.
/// </description></item>
/// <item><description>For refined Soundex, the return value can be greater than 4.</description></item>
/// </list>
/// <para/>
/// See: <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/tsqlref/ts_de-dz_8co5.asp">
/// MS T-SQL DIFFERENCE</a>
/// </summary>
/// <param name="encoder">The encoder to use to encode the strings.</param>
/// <param name="s1">A string that will be encoded and compared.</param>
/// <param name="s2">A string that will be encoded and compared.</param>
/// <returns>The number of characters in the two Soundex encoded strings that are the same.</returns>
/// <seealso cref="DifferenceEncoded(string, string)"/>
public static int Difference(IStringEncoder encoder, string s1, string s2)
{
return(DifferenceEncoded(encoder.Encode(s1), encoder.Encode(s2)));
}
public SocketSender(Socket socket)
: base(socket)
{
_stringEncoder = new StringEncoder();
}
/// <summary>
/// Initial object
/// </summary>
/// <param name="con">Socket Connection</param>
/// <param name="bufferSize">Buffer size</param>
/// <param name="receiveDataSize">Data size read from server</param>
public SocketReceiver(Socket socket, int bufferSize = 1024, int receiveDataSize = 128)
: base(socket, bufferSize, receiveDataSize)
{
_stringEncoder = new StringEncoder();
}
