public ProtoBufServiceMap(ISerializerCache serializerCache, OperationDefinition operationDefinition, RequestValueDefinition requestValueDefinition, ResponseValueDefinition responseValueDefinition, ITypeMap inputTypeMap, ITypeMap outputTypeMap) : base(serializerCache, operationDefinition, requestValueDefinition, responseValueDefinition, inputTypeMap, outputTypeMap) { var requestType = RequestValueDefinition.ParameterInfo?.ParameterType; var responseType = ResponseValueDefinition.ParameterInfo?.ParameterType; readRequestMethod = BuildReadValueMethod(requestType); readResponseMethod = BuildReadValueMethod(responseType); writeRequestMethod = BuildWriteValueMethod(requestType); writeResponseMethod = BuildWriteValueMethod(responseType); }
/// <summary> /// Initializes new ServiceMap entity using settings specified in operationDefinition. /// <param name="serializerCache">Provides TypeMap lookup.</param> /// <param name="operationDefinition">Operation which this ServiceMap represents.</param> /// <param name="requestValueDefinition">Defines operation request message.</param> /// <param name="responseValueDefinition">Defines operation response message.</param> /// <param name="inputTypeMap">Default TypeMap of the operation request root element.</param> /// <param name="outputTypeMap"> Default TypeMap of the operation response root element.</param> /// </summary> public ServiceMap(ISerializerCache serializerCache, OperationDefinition operationDefinition, RequestValueDefinition requestValueDefinition, ResponseValueDefinition responseValueDefinition, ITypeMap inputTypeMap, ITypeMap outputTypeMap) { this.serializerCache = serializerCache; RequestValueDefinition = requestValueDefinition; ResponseValueDefinition = responseValueDefinition; OperationDefinition = operationDefinition; var inputContentTypeMap = inputTypeMap as IContentTypeMap; this.inputTypeMap = inputContentTypeMap != null && requestValueDefinition.UseXop ? inputContentTypeMap.GetOptimizedContentTypeMap() : inputTypeMap; var outputContentTypeMap = outputTypeMap as IContentTypeMap; this.outputTypeMap = outputContentTypeMap != null && responseValueDefinition.UseXop ? outputContentTypeMap.GetOptimizedContentTypeMap() : outputTypeMap; }
public void Setup() { serializer = mockSerializer.Object; serializerCache = mockSerializerCache.Object; packageFactory = mockPackageFactory.Object; package = new DataPackage <string>(new GuidPackageId(), obj); mockPackageFactory .Setup(m => m.Pack(It.IsAny <object>())) .Returns(package); mockPackageFactory .Setup(m => m.Unpack(It.IsAny <Package>())) .Returns(obj); mockSerializer .Setup(m => m.Descriptor) .Returns(dotNetSerializer.Descriptor); mockSerializer .Setup(m => m.Serialize(It.IsAny <Package>())) .Returns <Package>(p => dotNetSerializer.Serialize(p)); mockSerializer .Setup(m => m.Serialize(It.IsAny <object>(), It.IsAny <int>())) .Returns <Package, int>((obj, offset) => dotNetSerializer.Serialize(obj, offset)); mockSerializer .Setup(m => m.Deserialize <Package>(It.IsAny <byte[]>())) .Returns <byte[]>(d => dotNetSerializer.Deserialize <Package>(d)); mockSerializer .Setup(m => m.Deserialize <Package>(It.IsAny <byte[]>(), It.IsAny <int>())) .Returns <byte[], int>((data, offset) => dotNetSerializer.Deserialize <Package>(data, offset)); mockSerializerCache .Setup(m => m.DefaultSerializer) .Returns(serializer); }
public PropertyMap(ISerializerCache serializerCache, PropertyDefinition propertyDefinition, ITypeMap typeMap, IEnumerable <string> availableFilters) { this.serializerCache = serializerCache; var contentTypeMap = typeMap as IContentTypeMap; this.typeMap = contentTypeMap != null && propertyDefinition.UseXop ? contentTypeMap.GetOptimizedContentTypeMap() : typeMap; Definition = propertyDefinition; getValueMethod = Definition.PropertyInfo.CreateGetValueMethod(); setValueMethod = Definition.PropertyInfo.CreateSetValueMethod(); if (availableFilters == null) { return; } foreach (var availableFilter in availableFilters.Where(f => Definition.DeclaringTypeDefinition.Type.IsFilterableField(Definition.RuntimeName, f))) { filters.Add(availableFilter); } }
/// <summary> /// Initializes a new instance of <see cref="NetMQMessageFactory"/> /// </summary> /// <param name="serializerCache">A serializer that will convert data into a binary format for transmission</param> /// <param name="packageFactory">Wraps objects in a packages</param> public NetMQMessageFactory(ISerializerCache serializerCache, IPackageFactory packageFactory) { this.serializerCache = serializerCache ?? throw new ArgumentNullException(nameof(serializerCache)); this.packageFactory = packageFactory ?? throw new ArgumentNullException(nameof(packageFactory)); }
protected CompositeTypeMap(ISerializerCache serializerCache, TypeDefinition typeDefinition) : base(typeDefinition) { this.serializerCache = serializerCache; }
public SequenceTypeMap(ISerializerCache serializerCache, TypeDefinition typeDefinition) : base(serializerCache, typeDefinition) { }
public ArrayTypeMap(ISerializerCache serializerCache, CollectionDefinition collectionDefinition, ITypeMap elementTypeMap) : base(collectionDefinition) { this.serializerCache = serializerCache; this.elementTypeMap = elementTypeMap; }
private static ITypeMap GetPropertyTypeMap(string customTypeName, Type runtimeType, bool isArray, IDictionary <Type, ITypeMap> partialTypeMaps, ISerializerCache serializerCache) { return(string.IsNullOrWhiteSpace(customTypeName) ? serializerCache.GetTypeMap(runtimeType, partialTypeMaps) : serializerCache.GetTypeMap(XName.Get(customTypeName, NamespaceConstants.XSD), isArray)); }
public AllTypeMap(ISerializerCache serializerCache, TypeDefinition typeDefinition) : base(serializerCache, typeDefinition) { requiredPropertiesCount = new Lazy <int>(() => deserializationPropertyMaps.Where(x => !x.Value.Definition.IsOptional).Count()); }