public RefactorerContext (ProjectDom ctx, ITextFileProvider files, IType cls)
{
this.files = files;
this.ctx = ctx;
if (cls != null)
typeResolver = GetTypeNameResolver (cls);
}
public EventCriteria BuildCriteria(ITypeNameResolver typeNameResolver)
{
var filters = new List <FilterDefinition <RecordedEvent> >();
IEnumerable <string> eventNames = _eventTypes
.Select(t => typeNameResolver.GetTypeName(t))
.ToArray();
if (_streamIDs.Any())
{
filters.Add(Builders <RecordedEvent> .Filter.In("Event._t", eventNames));
}
if (_eventTypes.Any())
{
filters.Add(Builders <RecordedEvent> .Filter.In(x => x.StreamID, _streamIDs));
}
FilterDefinition <RecordedEvent> filter = filters.Count switch {
0 => Builders <RecordedEvent> .Filter.Empty,
1 => filters.Single(),
_ => Builders <RecordedEvent> .Filter.And(filters)
};
return(new EventCriteria(filter));
}
}
public Papyrus2ClrCecilConverter(IUserInterface userInterface, INameConventionResolver nameConventionResolver,
INamespaceResolver namespaceResolver, ITypeReferenceResolver typeReferenceResolver)
: base(namespaceResolver, typeReferenceResolver)
{
this.userInterface = userInterface;
this.nameConventionResolver = nameConventionResolver;
}
public static void AddAggressiveInlining(this ICsClassMember csMethod, ITypeNameResolver cl)
{
var atr = CsAttribute.Make <MethodImplAttribute>(cl)
.WithArgumentCode(cl.GetTypeName <MethodImplOptions>() + "." + MethodImplOptions.AggressiveInlining);
csMethod.Attributes.Add(atr);
}
protected static string MakeGenericType <TGenericType>(ITypeNameResolver reslve, string arg)
{
var tn = reslve.GetTypeName <TGenericType>();
var parts = tn.Split('<');
return(parts[0] + "<" + arg + ">");
}
public OptionValueProcessorInput(string expression,
OptionValueProcessorKind kind,
ITypeNameResolver resolver)
{
Expression = expression;
Kind = kind;
Resolver = resolver;
}
/// <summary>
/// Initializes a new <see cref="TypedConverter"/> with the given type.
/// The given type name resolver removes the need for <see cref="JsonTypeNameAttribute"/>s
/// to be present.
/// </summary>
/// <param name="type">The base type.</param>
/// <param name="typeNameResolver">A type name resolver is already populated
/// with type name mappings.</param>
/// <param name="typeProperty">The name of the JSON property which should
/// be used to encode the type information.</param>
public TypedConverter(Type type, ITypeNameResolver typeNameResolver, string typeProperty)
: base(type)
{
mBaseClassConverter = new ObjectConverter(type);
((IConverterInitialization)mBaseClassConverter).InitializeConverter();
mTypeNameResolver = typeNameResolver ?? throw new ArgumentNullException(nameof(typeNameResolver));
mTypeProperty = typeProperty ?? throw new ArgumentNullException(nameof(typeProperty));
}
public PropInfo MakeList(ITypeNameResolver resolver)
{
var type = resolver.GetTypeName <IList <int> >().Split('<').First();
var init = resolver.GetTypeName <List <int> >().Split('<').First();
PropertyInit = $"new {init}<{ElementType}>()";
PropertyType = $"{type}<{ElementType}>";
return(this);
}
public PropInfo MakeDict(ITypeNameResolver resolver)
{
var type = resolver.GetTypeName <IDictionary <int, int> >().Split('<').First();
var init = resolver.GetTypeName <Dictionary <int, int> >().Split('<').First();
PropertyInit = $"new {init}<string, {ElementType}>()";
PropertyType = $"{type}<string, {ElementType}>";
return(this);
}
public RefactorerContext(ProjectDom ctx, ITextFileProvider files, IType cls)
{
this.files = files;
this.ctx = ctx;
if (cls != null)
{
typeResolver = GetTypeNameResolver(cls);
}
}
public static string GetTypeName(this ITypeNameResolver res, NamespaceAndName typeName)
{
if (res is INamespaceContainer container)
{
if (container.IsKnownNamespace(typeName.Namespace))
{
return(typeName.Name);
}
}
return(typeName.FullName);
}
public MongoEventStoreSerializatonSettings(
IBsonSerializer streamIDSerializer,
IBsonSerializer <object> eventSerializer,
IBsonSerializer <object> metadataSerializer,
ITypeNameResolver typeNameResolver
)
{
StreamIDSerializer = Check.NotNull(streamIDSerializer, nameof(streamIDSerializer));
EventSerializer = Check.NotNull(eventSerializer, nameof(eventSerializer));
MetadataSerializer = Check.NotNull(metadataSerializer, nameof(metadataSerializer));
TypeNameResolver = Check.NotNull(typeNameResolver, nameof(typeNameResolver));
}
public PropInfo GetPropertyTypeName(OptionValueProcessorKind kind, ITypeNameResolver res,
NamespaceAndName enumTypeName)
{
var v = ValueType.FixedType;
string elementName;
if (v != null)
{
switch (kind)
{
case OptionValueProcessorKind.List:
case OptionValueProcessorKind.Dictionary:
elementName = res.GetTypeName(v);
break;
case OptionValueProcessorKind.SingleValue:
if (v.IsValueType)
{
v = typeof(Nullable <>).MakeGenericType(v);
}
elementName = res.GetTypeName(v);
break;
default:
throw new ArgumentOutOfRangeException(nameof(kind), kind, null);
}
}
else
{
var suffix = kind == OptionValueProcessorKind.SingleValue ? "?" : ";";
elementName = res.GetTypeName(enumTypeName) + suffix;
}
var tqq = new PropInfo(elementName);
switch (kind)
{
case OptionValueProcessorKind.Dictionary:
return(tqq.MakeDict(res));
case OptionValueProcessorKind.SingleValue:
return(tqq);
case OptionValueProcessorKind.List:
return(tqq.MakeList(res));
default:
throw new ArgumentOutOfRangeException(nameof(kind), kind, null);
}
}
private static string GetStringValue(string chooseLongNameVariableName,
OptionsCollectionValue option, ITypeNameResolver resolver)
{
var longVersion = option.LongOptionWithMinus;
var shortVersion = option.ShortOptionWithMinus;
if (string.IsNullOrEmpty(longVersion))
{
return(shortVersion.CsEncode());
}
if (string.IsNullOrEmpty(shortVersion))
{
return(longVersion.CsEncode());
}
var conditions = chooseLongNameVariableName + " == " + resolver.GetEnumValueCode(OptionPreference.Long);
return(string.Format("{0} ? {1} : {2}", conditions,
longVersion.CsEncode(),
shortVersion.CsEncode()));
}
public ElasticSearchBufferedWriter(Func <ElasticClient> elasticClientFactory, IIndexNameResolver indexNameResolver, ITypeNameResolver typeNameResolver, Action throwOnMissingConfiguration)
{
if (elasticClientFactory == null)
{
throw new ArgumentNullException("elasticClientFactory");
}
if (indexNameResolver == null)
{
throw new ArgumentNullException("indexNameResolver");
}
if (typeNameResolver == null)
{
throw new ArgumentNullException("typeNameResolver");
}
if (throwOnMissingConfiguration == null)
{
throw new ArgumentNullException("throwOnMissingConfiguration");
}
_elasticClientFactory = elasticClientFactory;
_indexNameResolver = indexNameResolver;
_typeNameResolver = typeNameResolver;
_throwOnMissingConfiguration = throwOnMissingConfiguration;
}
public static void ConfigureSerialization(MongoEventStoreSerializatonSettings settings)
{
// TODO: Is there a less global way??
BsonDefaults.GuidRepresentation = GuidRepresentation.Standard;
__typeNameResolver = settings.TypeNameResolver;
IBsonSerializer streamIDSerializer = new CastSerializer <object>(settings.StreamIDSerializer);
BsonClassMap.RegisterClassMap <RecordedEvent>(m => {
m.MapIdProperty(x => x.ID).SetSerializer(EventIDSerializer.CastInstance);
m.MapProperty(x => x.StreamID).SetSerializer(streamIDSerializer);
m.MapProperty(x => x.Event).SetElementName("e").SetSerializer(settings.EventSerializer);
m.MapProperty(x => x.Metadata).SetElementName("m").SetSerializer(settings.MetadataSerializer);
m.MapCreator(x => new RecordedEvent(x.StreamID, x.Event, x.Metadata));
});
BsonClassMap.RegisterClassMap <StreamInfo>(m => {
m.MapIdField(x => x.StreamID).SetSerializer(streamIDSerializer);
m.MapCreator(x => new StreamInfo(x.StreamID));
});
// Required for the 'Max' query in 'EnsureGenerator'
BsonSerializer.RegisterSerializer(EventIDSerializer.Instance);
}
public static void CheckArgument(this CsCodeWriter code, string argName, ArgChecking flags,
ITypeNameResolver resolver)
{
if (flags == ArgChecking.None)
{
return;
}
var canBeNull = true;
var argNameToRead = argName + "?";
if ((flags & ArgChecking.NotNull) != 0)
{
var throwCode = new CsArguments($"nameof({argName})")
.Throw <NullReferenceException>(resolver);
code.SingleLineIf($"{argName} is null", throwCode);
canBeNull = false;
argNameToRead = argName;
}
if ((flags & ArgChecking.TrimValue) != 0)
{
code.WriteLine("{0} = {1}.Trim();", argName, argNameToRead);
flags &= ~ArgChecking.TrimValue;
if ((flags & ArgChecking.NotWhitespace) != 0)
{
flags &= ~ArgChecking.NotWhitespace;
flags |= ArgChecking.NotEmpty;
}
}
if ((flags & ArgChecking.NotNull) != 0 && canBeNull)
{
flags &= ~ArgChecking.NotNull;
//p.Attributes.Add(CsAttribute.Make<NotNullAttribute>(target));
var throwCode = new CsArguments($"nameof({argName})")
.Throw <NullReferenceException>(resolver);
code.SingleLineIf($"{argName} is null", throwCode);
}
if ((flags & ArgChecking.NotWhitespace) != 0)
{
flags &= ~(ArgChecking.NotEmpty | ArgChecking.NotWhitespace);
// var m = nameof(string.IsNullOrWhiteSpace);
var throwCode = new CsArguments($"nameof({argName})")
.Throw <ArgumentException>(resolver);
code.SingleLineIf($"string.IsNullOrWhiteSpace({argName})", throwCode);
flags &= ~(ArgChecking.NotNullOrWhitespace | ArgChecking.NotNullOrEmpty);
}
if ((flags & ArgChecking.NotEmpty) != 0)
{
flags &= ~ArgChecking.NotEmpty;
var throwCode = new CsArguments($"nameof({argName})")
.Throw <ArgumentException>(resolver);
var condition =
canBeNull
? $"string.IsNullOrEmpty({argName})"
: $"{argName}.Length == 0";
code.SingleLineIf(condition, throwCode);
}
}
public static void AddRelatedUnitSourceAttribute(this IAttributable attributable, ITypeNameResolver resolver,
RelatedUnitSourceUsage flag, int sortOrder)
{
var argument = resolver.GetEnumValueCode(flag);
var csAttribute = new CsAttribute(nameof(RelatedUnitSourceAttribute))
.WithArgumentCode(argument);
if (flag != RelatedUnitSourceUsage.DoNotUse)
{
csAttribute.WithArgument(sortOrder);
}
attributable.WithAttribute(csAttribute);
}
public void AddFlagsAttribute(ITypeNameResolver resolver)
{
_target.WithAttribute(new CsAttribute(resolver.GetTypeName <FlagsAttribute>()));
}
public string Create <T>(ITypeNameResolver resolver)
{
return(Create(resolver.GetTypeName <T>()));
}
public string Throw <T>(ITypeNameResolver resolver)
{
var exc = Create(resolver.GetTypeName <T>());
return($"throw {exc};");
}
public ElasticSearchBufferedWriter(Func <ElasticClient> elasticClientFactory,
IIndexNameResolver indexNameResolver, ITypeNameResolver typeNameResolver)
: this(elasticClientFactory, indexNameResolver, typeNameResolver, ConfigChecker.EnsureRequiredConfiguration)
{
}
protected static string MakeGenericType <TGenericType>(ITypeNameResolver reslve, ITypeNameProvider arg)
{
return(MakeGenericType <TGenericType>(reslve, arg.GetTypename()));
}
public TypeReferenceResolver(INamespaceResolver namespaceResolver,
ITypeNameResolver typeNameResolver)
{
this.namespaceResolver = namespaceResolver;
this.typeNameResolver = typeNameResolver;
}
