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