public static void serialize <T>(T serializeObject)
{
//this is fine...
SerializableEntity <T> entity =
new SerializableEntity <T>(serializeObject);
}
/// <summary>
/// Creates new instance of
/// <see cref="Apache.Http.HttpEntity">Apache.Http.HttpEntity</see>
/// based on the current state.
/// </summary>
public virtual HttpEntity Build()
{
AbstractHttpEntity e;
if (this.text != null)
{
e = new StringEntity(this.text, GetContentOrDefault(ContentType.DefaultText));
}
else
{
if (this.binary != null)
{
e = new ByteArrayEntity(this.binary, GetContentOrDefault(ContentType.DefaultBinary
));
}
else
{
if (this.stream != null)
{
e = new InputStreamEntity(this.stream, 1, GetContentOrDefault(ContentType.DefaultBinary
));
}
else
{
if (this.parameters != null)
{
e = new UrlEncodedFormEntity(this.parameters, this.contentType != null ? this.contentType
.GetCharset() : null);
}
else
{
if (this.serializable != null)
{
e = new SerializableEntity(this.serializable);
e.SetContentType(ContentType.DefaultBinary.ToString());
}
else
{
if (this.file != null)
{
e = new FileEntity(this.file, GetContentOrDefault(ContentType.DefaultBinary));
}
else
{
e = new BasicHttpEntity();
}
}
}
}
}
}
if (e.GetContentType() != null && this.contentType != null)
{
e.SetContentType(this.contentType.ToString());
}
e.SetContentEncoding(this.contentEncoding);
e.SetChunked(this.chunked);
if (this.gzipCompress)
{
return(new GzipCompressingEntity(e));
}
return(e);
}
private EntityDataKey GetEntityKey(QueryStructuralType type, SerializableEntity entity)
{
ExceptionUtilities.CheckArgumentNotNull(type, "type");
ExceptionUtilities.CheckArgumentNotNull(entity, "entity");
return(EntityDataKey.CreateFromValues(entity.Properties.Where(p => type.Properties.Any(k => k.IsPrimaryKey && k.Name == p.Name)).Select(p => this.DataOracleConverter.Convert(p))));
}
private void ConvertEntityProperty(SerializableEntity entity, EntityContainerData data, Dictionary<SerializableEntity, EntitySetDataRow> rowMap)
{
var row = rowMap[entity];
foreach (var prop in entity.Properties)
{
var relatedRows = prop.Value as IEnumerable<SerializableEntity>;
var relatedRow = prop.Value as SerializableEntity;
if (relatedRows == null)
{
if (relatedRow != null)
{
relatedRows = new[] { relatedRow };
}
}
if (relatedRows != null)
{
var type = row.EntityType;
var navprop = type.AllNavigationProperties.Single(c => c.Name == prop.Name);
// handle MEST scenario where there are multiple association sets corresponding to a navigation property
var assocSets = data.EntityContainer.AssociationSets.Where(c => c.AssociationType == navprop.Association);
var assocSet = assocSets.Single(set => set.Ends.Any(end => end.AssociationEnd == navprop.FromAssociationEnd && end.EntitySet.Name == entity.EntitySetName));
var associationSetData = data[assocSet];
foreach (var rr in relatedRows)
{
if (!associationSetData.Rows.Where(c => c.GetRoleKey(navprop.FromAssociationEnd.RoleName) == row.Key && c.GetRoleKey(navprop.ToAssociationEnd.RoleName) == rowMap[rr].Key).Any())
{
var associationRow = associationSetData.AddNewRow();
associationRow.SetRoleKey(navprop.FromAssociationEnd.RoleName, row.Key);
associationRow.SetRoleKey(navprop.ToAssociationEnd.RoleName, rowMap[rr].Key);
}
}
}
else
{
// it could still be a null navigation property
var navigation = row.EntityType.AllNavigationProperties.SingleOrDefault(p => p.Name == prop.Name);
if (navigation == null)
{
var namedValue = this.Convert(prop);
row.SetValue(namedValue.Name, namedValue.Value);
}
}
}
}
/// <summary>
/// Finds the structural value for the given serializable entity and updates it, or create it if it does not exist
/// </summary>
/// <param name="baseType">The base type of the entity's set</param>
/// <param name="entity">The entity to find and synchronize</param>
/// <param name="existingEntityGraph">The existing entities in the set, mapped by key</param>
/// <returns>The synchronized entity</returns>
private QueryStructuralValue FindAndSynchronizeEntity(QueryEntityType baseType, SerializableEntity entity, IDictionary <EntityDataKey, QueryStructuralValue> existingEntityGraph)
{
QueryStructuralValue alreadySynchronized;
if (this.synchronizationCache.TryGetValue(entity, out alreadySynchronized))
{
return(alreadySynchronized);
}
// if the type does not match, it must be a derived type
var type = baseType;
if (type.EntityType.FullName != entity.EntityType)
{
type = type.DerivedTypes.Cast <QueryEntityType>().SingleOrDefault(t => t.EntityType.FullName == entity.EntityType);
ExceptionUtilities.CheckObjectNotNull(type, "Could not find a type named '{0}'", entity.EntityType);
}
// compute the key for the entity
var key = this.GetEntityKey(type, entity);
QueryStructuralValue structural;
bool isNewInstance = !existingEntityGraph.TryGetValue(key, out structural);
// if we don't find it, create it
if (isNewInstance)
{
structural = type.CreateNewInstance();
InitMemberStreamTypes(type, structural);
}
this.synchronizationCache[entity] = structural;
this.SynchronizeProperties(baseType, entity, type, structural, existingEntityGraph);
this.SynchronizeStreams(entity, structural);
structural.MarkDynamicPropertyValues();
// if its a new instance, add it to the top-level collection
if (isNewInstance)
{
this.QueryDataSet[type.EntitySet.Name].Elements.Add(structural);
existingEntityGraph[this.GetEntityKey(structural)] = structural;
}
return(structural);
}
