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; }