private string Format(IObjectFormatter type, object value)
{
var formattedValue = type.Format(value);
if (IsPositional)
{
return(formattedValue);
}
char separator;
if (ContainingSet.Attribute.AllowNamedArgumentValueAsSucceedingToken &&
ContainingSet.Attribute.PreferNamedArgumentValueAsSucceedingToken)
{
separator = ' ';
}
else
{
separator = ContainingSet.Attribute.ArgumentValueSeparators.FirstOrDefault();
}
return(string.Concat(
ContainingSet.Attribute.NamedArgumentPrefixes.FirstOrDefault() ?? string.Empty,
LongName,
separator,
formattedValue));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="innerType">The base IArgumentType instance to
/// wrap and extend.</param>
/// <param name="parser">Optionally provides an override implementation
/// of the base argument type's string parser implementation.</param>
/// <param name="formatter">Optionally provides an override
/// implementation of the base argument type's object formatter
/// implementation.</param>
/// <param name="completer">Optionally provides an override
/// implementation of the base argument type's string completer
/// implementation.</param>
public ArgumentTypeExtension(IArgumentType innerType, IStringParser parser = null, IObjectFormatter formatter = null, IStringCompleter completer = null)
{
InnerType = innerType;
Parser = parser;
Formatter = formatter;
Completer = completer;
}
/// <summary>
/// Initializes a new instance of the <see cref="EvaluationContext"/> class.
/// </summary>
/// <param name="ignoreEvaluationExceptions">If set to <c>true</c>, ignores evaluation exceptions.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="identifierComparer">The identifier comparer.</param>
/// <param name="objectFormatter">The object formatter.</param>
/// <param name="selfObject">The <c>self</c> object that exposes all global identifiers.</param>
/// <param name="unParsedTextHandler">The un-parsed text handler delegate.</param>
public EvaluationContext(
bool ignoreEvaluationExceptions,
CancellationToken cancellationToken,
[NotNull] IEqualityComparer <string> identifierComparer,
[NotNull] IObjectFormatter objectFormatter,
[CanBeNull] object selfObject,
[NotNull] Func <IExpressionEvaluationContext, string, string> unParsedTextHandler)
{
Expect.NotNull(nameof(identifierComparer), identifierComparer);
Expect.NotNull(nameof(objectFormatter), objectFormatter);
Expect.NotNull(nameof(unParsedTextHandler), unParsedTextHandler);
CancellationToken = cancellationToken;
_identifierComparer = identifierComparer;
_objectFormatter = objectFormatter;
IgnoreEvaluationExceptions = ignoreEvaluationExceptions;
_unParsedTextHandler = unParsedTextHandler;
_selfObject = selfObject;
_disembowelers = new Dictionary <Type, SimpleTypeDisemboweler>();
_frames = new Stack <Frame>();
_dynamicInvoker = new SimpleDynamicInvoker();
OpenEvaluationFrame();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="innerType">The base IArgumentType instance to
/// wrap and extend.</param>
/// <param name="parser">Optionally provides an override implementation
/// of the base argument type's string parser implementation.</param>
/// <param name="formatter">Optionally provides an override
/// implementation of the base argument type's object formatter
/// implementation.</param>
/// <param name="completer">Optionally provides an override
/// implementation of the base argument type's string completer
/// implementation.</param>
public ArgumentTypeExtension(IArgumentType innerType, IStringParser parser, IObjectFormatter formatter, IStringCompleter completer)
{
InnerType = innerType;
Parser = parser;
Formatter = formatter;
Completer = completer;
}
/// <summary>
/// Initializes a new instance of the <see cref="FlexiblePrimitiveTypeConverter" /> class.
/// </summary>
/// <param name="formatProvider">Formatting options used to parse string values. Primarily used when parsing <see cref="double" /> values.</param>
/// <param name="objectFormatter">The object formatter.</param>
/// <exception cref="ArgumentNullException">Argument <paramref name="formatProvider" /> or <paramref name="objectFormatter" /> is <c>null</c>.</exception>
public FlexiblePrimitiveTypeConverter([NotNull] IFormatProvider formatProvider, [NotNull] IObjectFormatter objectFormatter)
{
Expect.NotNull(nameof(formatProvider), formatProvider);
Expect.NotNull(nameof(objectFormatter), objectFormatter);
FormatProvider = formatProvider;
ObjectFormatter = objectFormatter;
}
public DefaultProtocol(IProtocolFactory factory,
ProtocolOptions options)
{
m_buffer = new Buffer <byte>(options.BufferSize);
m_factory = factory;
Options = options;
m_keyEncoder = factory.CreateEncoder();
m_builder = factory.CreatePacketBuilder(m_buffer);
m_formatter = factory.CreateObjectFormatter();
m_commandWriter = factory.CreateCommandWriter(m_builder);
}
private object Convert(string value, IObjectFormatter objectFormatter)
{
try
{
var format = objectFormatter.Format(value);
Debug.WriteLine($"String {value} is converted to {format}");
return(format);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
return(null);
}
private dynamic Convert(string value, IObjectFormatter objectFormatter)
{
try
{
object format = objectFormatter.Format(value);
Logger.DebugFormat("String {0} is converted to {1}", value, format);
return(format);
}
catch (Exception e)
{
Logger.Error("convert " + value + " to " + objectFormatter.GetType() + " error!", e);
}
return(null);
}
private List <object> Convert(List <string> values, IObjectFormatter objectFormatter)
{
var objects = new List <object>();
foreach (var value in values)
{
var converted = Convert(value, objectFormatter);
if (converted != null)
{
objects.Add(converted);
}
}
return(objects);
}
private string Format(IObjectFormatter type, object value)
{
var formattedValue = type.Format(value);
if (_isPositional)
{
return(formattedValue);
}
return(string.Concat(
_setAttribute.NamedArgumentPrefixes.FirstOrDefault() ?? string.Empty,
LongName,
_setAttribute.ArgumentValueSeparators.FirstOrDefault(),
formattedValue));
}
public SimpleTypeDisemboweler(
[NotNull] Type type,
[NotNull] IEqualityComparer <string> memberComparer,
[NotNull] IObjectFormatter objectFormatter)
{
Expect.NotNull(nameof(type), type);
Expect.NotNull(nameof(memberComparer), memberComparer);
Expect.NotNull(nameof(objectFormatter), objectFormatter);
Type = type;
Comparer = memberComparer;
ObjectFormatter = objectFormatter;
_cachedMemberMap = new Dictionary <string, Func <object, object[], object> >();
}
public PeerConnection(Socket socket, EndPoint endpoint, Action <PeerConnection> disposeCallback)
{
_endpoint = endpoint;
_disposeCallback = disposeCallback;
_socket = socket;
_stream = new NetworkStream(_socket, FileAccess.ReadWrite, true);
_stream.ReadTimeout = 1200000;
_stream.WriteTimeout = 10000;
_decoder = new BDecode(_stream);
_formatter = new BEncodeObjectFormatter(_stream);
_serializer = new BasicObjectSerializer(_formatter);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="type">The primitive object type to find a corresponding
/// IArgumentType implementation for (e.g. System.String).</param>
/// <param name="parser">Optionally provides an override implementation
/// of the base argument type's string parser implementation.</param>
/// <param name="formatter">Optionally provides an override
/// implementation of the base argument type's object formatter
/// implementation.</param>
/// <param name="completer">Optionally provides an override
/// implementation of the base argument type's string completer
/// implementation.</param>
public ArgumentTypeExtension(Type type, IStringParser parser = null, IObjectFormatter formatter = null, IStringCompleter completer = null) : this(ArgumentType.GetType(type), parser, formatter, completer)
{
}
/// <summary>
/// Устанавливает способ форматирования.
/// </summary>
public void SetFormatter(IObjectFormatter value)
{
Control.Formatter = value;
}
private static bool TryScanForObjectFormatter <T>(out Type key, out IObjectFormatter <T> objectFormatter)
{
//var interfaces = type.FindInterfaces(((m, filterCriteria) => m == s_objectParserBuilderType), null);
throw new NotImplementedException();
}
protected CompressedObjectFormatter(IObjectFormatter inner)
: base(inner)
{
}
public SimpleObjectFormatter(Encoding encoding, IObjectFormatter inner)
: base(inner)
{
m_encoding = encoding;
}
public ArrayObjectFormatter(IObjectFormatter inner)
: base(inner)
{
}
protected DecoratedObjectFormatter(IObjectFormatter inner)
{
Inner = inner;
}
public Formatter(string[] value, Type type = null, IObjectFormatter formatter = null)
{
Value = value;
SubType = type;
ObjectFormatter = formatter;
}
public static string Format <TValue>(IObjectFormatter <TValue> formatter, object obj)
{
return(Format <TValue>(formatter, obj, null));
}
public DeflateObjectFormatter(IObjectFormatter inner)
: base(inner)
{
CompressionThreshold = 64 * 1024;
}
private void CheckFormat(PropertyInfo field, FieldExtractor fieldExtractor)
{
//check custom formatter
Attribute.Formatter formatter = field.GetCustomAttribute <Attribute.Formatter>();
Type formatterType;
if (formatter?.ObjectFormatter != null)
{
// if (!formatter.formatter().equals(ObjectFormatter.class)) {
IObjectFormatter objectFormatter = formatter.ObjectFormatter;
objectFormatter.InitParam(formatter.Value);
fieldExtractor.ObjectFormatter = objectFormatter;
return;
// }
}
else
{
formatterType = FormatterFactory.GetFormatter(field.PropertyType);
}
if (!fieldExtractor.Multi)
{
IObjectFormatter objectFormatter = GetObjectFormatter(formatterType);
if (objectFormatter == null)
{
throw new Exception("Can't find formatter for field " + field.Name + " of type " + formatterType);
}
fieldExtractor.ObjectFormatter = objectFormatter;
}
else
{
if (!field.PropertyType.IsGenericType)
{
throw new SpiderExceptoin("Field " + field.Name + " must be generice type.");
}
Type[] genericType = field.PropertyType.GetGenericArguments();
if (genericType.Length != 1)
{
throw new SpiderExceptoin("Field " + field.Name + " must be single generice type like List<T> Hashset<T>. Not support Diction<K,V> etc...");
}
MethodInfo method = fieldExtractor.Field.PropertyType.GetMethod("Add", genericType);
if (method == null)
{
throw new SpiderExceptoin("Field " + field.Name + " did not contains Add(T t) method.");
}
IObjectFormatter objectFormatter = GetObjectFormatter(formatterType);
if (objectFormatter == null)
{
if (formatter != null)
{
throw new SpiderExceptoin("Can't find formatter for field " + field.Name + " of type " + formatter.SubType);
}
}
else
{
fieldExtractor.ObjectFormatter = objectFormatter;
}
}
}
public SymmetricObjectFormatter(ISymmetricAlgorithmProvider symmetricAlgorithmProvider, IObjectFormatter inner)
: base(inner)
{
var algorithm = symmetricAlgorithmProvider.Create();
m_encryptor = algorithm.CreateEncryptor();
m_decryptor = algorithm.CreateDecryptor();
}
protected EncryptedObjectFormatter(IObjectFormatter inner)
: base(inner)
{
}
public NullObjectFormatter(IObjectFormatter inner)
: base(inner)
{
}
private IList <dynamic> Convert(IList <string> values, IObjectFormatter objectFormatter)
{
return(values.Select(value => Convert(value, objectFormatter)).ToList());
}
public Formatter(string[] value, Type type = null, IObjectFormatter formatter = null)
{
Value = value;
SubType = type;
ObjectFormatter = formatter;
}
public RuntimeObjectFormatter(IFormatter formatter, IObjectFormatter inner)
: base(inner)
{
m_formatter = formatter;
}
public static string Format <TValue>(IObjectFormatter <TValue> formatter, object obj, Nparams param)
{
return(formatter.Format(obj, param));
}
public void Initialize(IObjectFormatter formatter)
{
Formatter = formatter;
}
