public void Init()
{
var serializer = new AggregateSerializer( new PlatformAdapter() );
serializer.AddSerializer(new DefaultSerializer());
serializer.AddSerializer(new TestSerializer());
_target = serializer;
}
/// <summary>
/// Add a new serializer
/// </summary>
/// <param name="serializer">The serializer</param>
public void AddSerializer(ISterlingSerializer serializer)
{
if (!_serializers.Contains(serializer))
{
_serializers.Add(serializer);
}
}
protected virtual ISterlingDriver GetDriver(string test, ISterlingSerializer serializer)
{
return(new MemoryDriver()
{
DatabaseInstanceName = test, DatabaseSerializer = serializer
});
}
public void Init()
{
var serializer = new AggregateSerializer(new PlatformAdapter());
serializer.AddSerializer(new DefaultSerializer());
serializer.AddSerializer(new TestSerializer());
_target = serializer;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">Database this is a helper for</param>
/// <param name="serializer">The serializer</param>
/// <param name="logManager">The logger</param>
/// <param name="typeResolver"></param>
/// <param name="typeIndexer"></param>
public SerializationHelper(ISterlingDatabaseInstance database, ISterlingSerializer serializer,
LogManager logManager, Func <string, int> typeResolver, Func <int, string> typeIndexer)
{
_database = database;
_serializer = serializer;
_logManager = logManager;
_typeResolver = typeResolver;
_typeIndexer = typeIndexer;
}
/// <summary>
/// Clone the aggregate serializer and leave out the requesting (to avoid infinite loops)
/// </summary>
/// <param name="serializer">The serializer requesting the aggregate clone</param>
/// <returns>An aggregate serializer that omits the requesting serializer</returns>
public ISterlingSerializer CloneFor(ISterlingSerializer serializer)
{
var aggregateSerializer = new AggregateSerializer( _platformAdapter );
var query = from s in _serializers where !s.GetType().Equals(serializer.GetType()) select s;
foreach(var s in query)
{
aggregateSerializer.AddSerializer(s);
}
return aggregateSerializer;
}
/// <summary>
/// Clone the aggregate serializer and leave out the requesting (to avoid infinite loops)
/// </summary>
/// <param name="serializer">The serializer requesting the aggregate clone</param>
/// <returns>An aggregate serializer that omits the requesting serializer</returns>
public ISterlingSerializer CloneFor(ISterlingSerializer serializer)
{
var aggregateSerializer = new AggregateSerializer();
var query = from s in _serializers where !s.GetType().Equals(serializer.GetType()) select s;
foreach (var s in query)
{
aggregateSerializer.AddSerializer(s);
}
return(aggregateSerializer);
}
protected override ISterlingDriver GetDriver( string test, ISterlingSerializer serializer )
{
#if NETFX_CORE
return new WindowsStorageDriver() { DatabaseInstanceName = test, DatabaseSerializer = serializer };
#elif SILVERLIGHT
return new IsolatedStorageDriver() { DatabaseInstanceName = test, DatabaseSerializer = serializer };
#elif AZURE_DRIVER
return new Wintellect.Sterling.Server.Azure.TableStorage.Driver() { DatabaseInstanceName = test, DatabaseSerializer = serializer };
#else
return new FileSystemDriver() { DatabaseInstanceName = test, DatabaseSerializer = serializer };
#endif
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Deactivate()
{
lock (Lock)
{
_activated = false;
_Unload();
_databases.Clear();
BaseDatabaseInstance.Deactivate();
_serializer = new AggregateSerializer();
}
return;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Deactivate()
{
lock (_lock)
{
if (_activated)
{
_activated = false;
_Unload();
_databases.Clear();
_serializer = new AggregateSerializer(Engine.PlatformAdapter);
}
}
}
protected override ISterlingDriver GetDriver(string test, ISterlingSerializer serializer)
{
#if NETFX_CORE
return(new WindowsStorageDriver()
{
DatabaseInstanceName = test, DatabaseSerializer = serializer
});
#elif SILVERLIGHT
return(new IsolatedStorageDriver()
{
DatabaseInstanceName = test, DatabaseSerializer = serializer
});
#elif AZURE_DRIVER
return(new Wintellect.Sterling.Server.Azure.TableStorage.Driver()
{
DatabaseInstanceName = test, DatabaseSerializer = serializer
});
#else
return(new FileSystemDriver()
{
DatabaseInstanceName = test, DatabaseSerializer = serializer
});
#endif
}
/// <summary>
/// Register a serializer with the system
/// </summary>
/// <typeparam name="T">The type of the serliaizer</typeparam>
public void RegisterSerializer <T>() where T : BaseSerializer
{
if (_activated)
{
throw new SterlingActivationException(string.Format("RegisterSerializer<{0}>", typeof(T).FullName));
}
ISterlingSerializer serializer = null;
if (typeof(T) == typeof(AggregateSerializer))
{
serializer = new AggregateSerializer(Engine.PlatformAdapter);
}
else if (typeof(T) == typeof(ExtendedSerializer))
{
serializer = new ExtendedSerializer(Engine.PlatformAdapter);
}
else
{
serializer = (ISterlingSerializer)Activator.CreateInstance(typeof(T));
}
((AggregateSerializer)_serializer).AddSerializer(serializer);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">Database</param>
/// <param name="serializer">Serializer</param>
/// <param name="log">Logging delegate</param>
protected BaseDriver(ISterlingDatabaseInstance database, ISterlingSerializer serializer, Action <SterlingLogLevel, string, Exception> log) : this()
{
this.Database = database;
this.DatabaseSerializer = serializer;
this.Log = log;
}
public SterlingSerializerException(ISterlingSerializer serializer, Type targetType) :
base(string.Format(Exceptions.SterlingSerializerException, serializer.GetType().FullName, targetType.FullName))
{
}
public SterlingSerializerException(ISterlingSerializer serializer, Type targetType) :
base(string.Format(Exceptions.SterlingSerializerException, serializer.GetType().FullName, targetType.FullName))
{
}
public void Init()
{
_target = new ExtendedSerializer( new PlatformAdapter() );
}
public MemoryDriver(string databaseName, ISterlingSerializer serializer, Action <SterlingLogLevel, string, Exception> log) : base(databaseName, serializer, log)
{
}
public SterlingDatabase(SterlingEngine engine)
{
Engine = engine;
TypeResolver = new TableTypeResolver();
_serializer = new AggregateSerializer(engine.PlatformAdapter);
}
public void Init()
{
_target = new ExtendedSerializer(new PlatformAdapter());
}
/// <summary>
/// Add a new serializer
/// </summary>
/// <param name="serializer">The serializer</param>
public void AddSerializer(ISterlingSerializer serializer)
{
if (!_serializers.Contains(serializer))
{
_serializers.Add(serializer);
}
}
public void Init()
{
_target = new DefaultSerializer();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="databaseName">Database</param>
/// <param name="serializer">Serializer</param>
/// <param name="log">Logging delegate</param>
protected BaseDriver(string databaseName, ISterlingSerializer serializer, Action <SterlingLogLevel, string, Exception> log) : this()
{
DatabaseName = databaseName;
DatabaseSerializer = serializer;
Log = log;
}
protected virtual ISterlingDriver GetDriver( string test, ISterlingSerializer serializer )
{
return new MemoryDriver() { DatabaseInstanceName = test, DatabaseSerializer = serializer };
}
public void Init()
{
_target = new DefaultSerializer();
}
public MemoryDriver(ISterlingDatabaseInstance database, ISterlingSerializer serializer, Action <SterlingLogLevel, string, Exception> log) : base(database, serializer, log)
{
}
public SterlingSerializerException(ISterlingSerializer serializer, Type targetType) :
base($"{serializer.GetType().FullName} {targetType.FullName}")
{
}
