public ColumnSerializer(
IPropertySerializer propertySerializer,
IColumnFactory factory)
: base(propertySerializer)
{
_factory = factory;
}
/// <summary>
/// Custom serializer and deserializer
/// </summary>
/// <param name = "serializer"></param>
/// <param name = "deserializer"></param>
public SharpSerializer(IPropertySerializer serializer, IPropertyDeserializer deserializer)
{
if (serializer == null) throw new ArgumentNullException("serializer");
if (deserializer == null) throw new ArgumentNullException("deserializer");
_serializer = serializer;
_deserializer = deserializer;
}
public ScatterPlotLayoutSerializer(
IPropertySerializer propertySerializer,
IColorPaletteFactory colorPaletteFactory)
: base(propertySerializer)
{
_colorPaletteFactory = colorPaletteFactory;
}
public ScatterPlotSerializer(
IPropertySerializer propertySerializer,
IScatterPlotLayoutSerializer layoutSerializer)
: base(propertySerializer)
{
_layoutSerializer = layoutSerializer;
}
private void Initialize(BinarySettings settings)
{
//RootName
RootName = settings.AdvancedSettings.RootName;
// TypeNameConverter)
var typeNameConverter = settings.AdvancedSettings.TypeNameConverter ??
DefaultInitializer.GetTypeNameConverter(
settings.IncludeAssemblyVersionInTypeName,
settings.IncludeCultureInTypeName,
settings.IncludePublicKeyTokenInTypeName);
// Create Serializer and Deserializer
IBinaryReader reader = null;
IBinaryWriter writer = null;
if (settings.Mode == BinarySerializationMode.Burst)
{
// Burst mode
writer = new BurstBinaryWriter(typeNameConverter, settings.Encoding);
reader = new BurstBinaryReader(typeNameConverter, settings.Encoding);
}
else
{
// Size optimized mode
writer = new SizeOptimizedBinaryWriter(typeNameConverter, settings.Encoding);
reader = new SizeOptimizedBinaryReader(typeNameConverter, settings.Encoding);
}
_deserializer = new BinaryPropertyDeserializer(reader);
_serializer = new BinaryPropertySerializer(writer);
}
private void initialize(SharpSerializerBinarySettings settings)
{
// PropertiesToIgnore
this.PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;
this.PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;
//RootName
this.RootName = settings.AdvancedSettings.RootName;
// TypeNameConverter)
ITypeNameConverter typeNameConverter = settings.AdvancedSettings.TypeNameConverter ??
DefaultInitializer.GetTypeNameConverter(
settings.IncludeAssemblyVersionInTypeName,
settings.IncludeCultureInTypeName,
settings.IncludePublicKeyTokenInTypeName);
// Create Serializer and Deserializer
Polenter.Serialization.Advanced.Binary.IBinaryReader reader = null;
Polenter.Serialization.Advanced.Binary.IBinaryWriter writer = null;
if (settings.Mode == BinarySerializationMode.Burst)
{
// Burst mode
writer = new BurstBinaryWriter(typeNameConverter, settings.Encoding);
reader = new BurstBinaryReader(typeNameConverter, settings.Encoding);
}
else
{
// Size optimized mode
writer = new SizeOptimizedBinaryWriter(typeNameConverter, settings.Encoding);
reader = new SizeOptimizedBinaryReader(typeNameConverter, settings.Encoding);
}
this._deserializer = new BinaryPropertyDeserializer(reader);
this._serializer = new BinaryPropertySerializer(writer);
}
private void initialize(SharpSerializerXmlSettings settings)
{
// PropertiesToIgnore
PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;
PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;
//RootName
RootName = settings.AdvancedSettings.RootName;
// TypeNameConverter)
ITypeNameConverter typeNameConverter = settings.AdvancedSettings.TypeNameConverter ??
DefaultInitializer.GetTypeNameConverter(
settings.IncludeAssemblyVersionInTypeName,
settings.IncludeCultureInTypeName,
settings.IncludePublicKeyTokenInTypeName);
// SimpleValueConverter
ISimpleValueConverter simpleValueConverter = settings.AdvancedSettings.SimpleValueConverter ??
DefaultInitializer.GetSimpleValueConverter(settings.Culture, typeNameConverter);
// XmlWriterSettings
XmlWriterSettings xmlWriterSettings = DefaultInitializer.GetXmlWriterSettings(settings.Encoding);
// XmlReaderSettings
XmlReaderSettings xmlReaderSettings = DefaultInitializer.GetXmlReaderSettings();
// Create Serializer and Deserializer
var reader = new DefaultXmlReader(typeNameConverter, simpleValueConverter, xmlReaderSettings);
var writer = new DefaultXmlWriter(typeNameConverter, simpleValueConverter, xmlWriterSettings);
_serializer = new XmlPropertySerializer(writer);
_deserializer = new XmlPropertyDeserializer(reader);
}
public AuthorizationCodeStore(
IAuthorizationCodeRepository repository,
IClientRepository clientRepository,
IPropertySerializer propertySerializer) : base(repository)
{
_clientRepository = clientRepository;
_propertySerializer = propertySerializer;
}
public EnumPropertySerializerDecorator(IEnumSerializer enumSerializer, IPropertySerializer propertySerializer)
{
ArgumentUtility.CheckNotNull("enumSerializer", enumSerializer);
ArgumentUtility.CheckNotNull("propertySerializer", propertySerializer);
_enumSerializer = enumSerializer;
_propertySerializer = propertySerializer;
}
public TokenHandleStore(
ITokenHandleRepository repository,
IPropertySerializer propertySerializer,
IClientRepository clientRepository) : base(repository)
{
_propertySerializer = propertySerializer;
_clientRepository = clientRepository;
}
public void CreateItem(ICoreData ItemData)
{
string _strDBName = GetDBPath();
IDbConnection _connection = new SqliteConnection(_strDBName);
IDbCommand _command = _connection.CreateCommand();
string tableName = "items";
string sql = "";
_connection.Open();
if (ItemData != null)
{
if (ItemData.BaseData is ISerializeData)
{
ISerializeData itemSerializeDataInterface = ItemData.BaseData as ISerializeData;
if (itemSerializeDataInterface == null)
{
Debug.LogError("The external DB item data does not implement the interface ISerializeData");
return;
}
IPropertySerializer propertiesInterface = ItemData.BaseData.Properties as IPropertySerializer;
string serializedProperties = string.Empty;
if (propertiesInterface != null)
{
serializedProperties = propertiesInterface.Serialize();
}
sql = string.Format("INSERT INTO " + tableName + " (item_uuid, type, data, properties)" +
" VALUES ( \"{0}\", \"{1}\", \"{2}\", \"{3}\");",
ItemData.BaseData.UniqueUUID,
ItemData.BaseData.Type,
itemSerializeDataInterface.SerializeItemData(),
serializedProperties
);
_command.CommandText = sql;
_command.ExecuteNonQuery();
}
else
{
Debug.LogError("External DB item [" + ItemData.BaseData.Name + "] does not implement ISerializeData interface.");
}
}
else
{
Debug.Log("The external DB item is null.");
}
_command.Dispose();
_command = null;
_connection.Close();
_connection = null;
}
public static IPropertySerializer GetSerializer(string type)
{
if (type.StartsWith("@"))
{
string contentType = type.Substring(1);
IPropertySerializer elementSerializer = GetSerializer(contentType);
if (elementSerializer != null)
{
return(new ArraySerializer(elementSerializer));
}
return(new ArraySerializer(new StructureSerializer <GenericObject>()));
}
if (type.StartsWith("*"))
{
return(new PointerSerializer());
}
if (type.StartsWith("~"))
{
return(new DependencySerializer());
}
if (type.StartsWith("E") && Char.IsUpper(type[1]))
{
// it's actually an enum but we simply deserialize the enum member name
return(new CNameSerializer());
}
switch (type)
{
case "String": return(new StringSerializer());
case "Int": return(new IntSerializer());
case "Uint": return(new UintSerializer());
case "Bool": return(new BoolSerializer());
case "Float": return(new FloatSerializer());
case "CName": return(new CNameSerializer());
case "LocalizedString": return(new LocalizedStringSerializer());
case "TagList": return(new TagListSerializer());
case "CVariant": return(new CVariantSerializer());
case "CGUID": return(new GuidSerializer());
case "EngineTransform": return(new EngineTransformSerializer());
default: return(null);
}
}
/// <summary>
/// Custom serializer and deserializer
/// </summary>
/// <param name = "serializer"></param>
/// <param name = "deserializer"></param>
public SharpSerializer(IPropertySerializer serializer, IPropertyDeserializer deserializer)
{
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
if (deserializer == null)
{
throw new ArgumentNullException("deserializer");
}
_serializer = serializer;
_deserializer = deserializer;
}
private static void ReadGenericObjectProperty(GenericObject target, IFileStream stream, string type, uint size, string name)
{
IPropertySerializer serializer = GetSerializer(type);
if (serializer != null)
{
target.SetProperty(name, type, serializer.Deserialize(stream));
}
else
{
uint valueSize = size - 4;
byte[] value = new byte[valueSize];
stream.SerializeValue(ref value, valueSize);
target.SetProperty(name, type, value);
}
}
private void Init()
{
IEnumerable <PropertyInfo> properties = this.TargetType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(prop =>
prop.GetIndexParameters().Length == 0 && prop.GetGetMethod(true) != null && prop.GetSetMethod(true) != null);
foreach (PropertyInfo propertyInfo in properties)
{
if (propertyInfo.GetAttribute <FastXmlIgnoreAttribute>() == null)
{
IPropertySerializer serializer = PropertySerializerFactory.Create(propertyInfo);
_serializeMap.Add(serializer.InputElementName, serializer);
_deserializeMap.Add(serializer.OutputElementName, serializer);
}
}
}
private void initialize(SharpSerializerXmlSettings settings) {
// PropertiesToIgnore
PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;
PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;
//RootName
RootName = settings.AdvancedSettings.RootName;
// TypeNameConverter)
var typeNameConverter = settings.AdvancedSettings.TypeNameConverter ?? DefaultInitializer.GetTypeNameConverter(settings.IncludeAssemblyVersionInTypeName, settings.IncludeCultureInTypeName, settings.IncludePublicKeyTokenInTypeName, settings.FindPluginAssembly);
// SimpleValueConverter
var simpleValueConverter = settings.AdvancedSettings.SimpleValueConverter ?? DefaultInitializer.GetSimpleValueConverter(settings.Culture, typeNameConverter);
// XmlWriterSettings
var xmlWriterSettings = DefaultInitializer.GetXmlWriterSettings(settings.Encoding);
// XmlReaderSettings
var xmlReaderSettings = DefaultInitializer.GetXmlReaderSettings();
// Create Serializer and Deserializer
var reader = new DefaultXmlReader(typeNameConverter, simpleValueConverter, xmlReaderSettings);
var writer = new DefaultXmlWriter(typeNameConverter, simpleValueConverter, xmlWriterSettings);
_serializer = new XmlPropertySerializer(writer);
_deserializer = new XmlPropertyDeserializer(reader);
}
public FakeSerializer(IPropertySerializer propertySerializer) : base(propertySerializer)
{
}
public BaseSerializer(IPropertySerializer propertySerializer)
{
_propertySerializer = propertySerializer;
}
public ParamParser(IPropertySerializer serializer)
{
Serializer = serializer;
}
public NullFilterSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
public StringFilterSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
public BooleanFilterSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
public IntegerFilterSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
public TableSerializer(IPropertySerializer propertySerializer)
{
ArgumentUtility.CheckNotNull("propertySerializer", propertySerializer);
_propertySerializer = propertySerializer;
}
public FloatFilterSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
public ParamParser(IPropertySerializer serializer)
{
Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
public DateTimeFilterSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
private void initialize(SharpSerializerBinarySettings settings) {
// PropertiesToIgnore
PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;
PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;
//RootName
RootName = settings.AdvancedSettings.RootName;
// TypeNameConverter)
var typeNameConverter = settings.AdvancedSettings.TypeNameConverter ?? DefaultInitializer.GetTypeNameConverter(settings.IncludeAssemblyVersionInTypeName, settings.IncludeCultureInTypeName, settings.IncludePublicKeyTokenInTypeName, settings.FindPluginAssembly);
// Create Serializer and Deserializer
IBinaryReader reader = null;
IBinaryWriter writer = null;
if (settings.Mode == BinarySerializationMode.Burst) {
// Burst mode
writer = new BurstBinaryWriter(typeNameConverter, settings.Encoding);
reader = new BurstBinaryReader(typeNameConverter, settings.Encoding);
}
else {
// Size optimized mode
writer = new SizeOptimizedBinaryWriter(typeNameConverter, settings.Encoding);
reader = new SizeOptimizedBinaryReader(typeNameConverter, settings.Encoding);
}
_deserializer = new BinaryPropertyDeserializer(reader);
_serializer = new BinaryPropertySerializer(writer);
}
public BaseItem[] GetAllItems(string player_uuid = "")
{
List <BaseItem> items = new List <BaseItem>();
string conn = GetDBPath();
IDbConnection dbconn = (IDbConnection) new SqliteConnection(conn);
dbconn.Open();
#region DB Structure
//CREATE TABLE `items` (
// `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
// `object_id` TEXT DEFAULT '00000000-0000-0000-0000-000000000000',
// `owner_id` INTEGER NOT NULL,
// `object_owner_id` TEXT,
// `type` TEXT NOT NULL,
// `data` BLOB NOT NULL,
// `position` BLOB NOT NULL,
// `rotation` BLOB NOT NULL
//);
#endregion DB Structure
IDbCommand dbcmd = dbconn.CreateCommand();
string sql = "";
if (string.IsNullOrEmpty(player_uuid))
{
sql = "SELECT id, item_uuid, type, data, properties " + "FROM items;";
}
else
{
sql = "SELECT id, item_uuid, type, data, properties " + "FROM items WHERE owner_uuid=\"" + player_uuid + "\";";
}
dbcmd.CommandText = sql;
IDataReader reader = dbcmd.ExecuteReader();
while (reader.Read())
{
//int id = reader.GetInt32(0);
//string item_uuid = reader.GetString(1);
//string type = reader.GetString(2);
string data = reader.GetString(3);
string propertiesData = reader.GetString(4);
var newData = Helper.FactoreData <SData>(data);
BaseItem extItemDB = null;
if (newData != null)
{
ISerializeData iSerializeInterface = newData as ISerializeData;
if (iSerializeInterface != null)
{
extItemDB = iSerializeInterface.FactoryCloneItemFromData();
}
else
{
Debug.Log("The external DB item data does not implement the ISerializable interface");
}
IPropertySerializer propertySerializerInterface = extItemDB.BaseData.Properties as IPropertySerializer;
if (propertySerializerInterface != null)
{
propertySerializerInterface.Deserialize <List <Property> >(propertiesData);
}
else
{
Debug.Log("The external DB item data property does not implement the interface IPropertySerializer");
}
}
if (items.Contains(extItemDB) == false && extItemDB != null)
{
items.Add(extItemDB);
}
else
{
Debug.LogError("Trying to add a duplicated external DB item skipping.");
}
}
reader.Close();
reader = null;
dbcmd.Dispose();
dbcmd = null;
dbconn.Close();
dbconn = null;
return(items.ToArray());
}
public RefreshTokenStore(
IRefreshTokenRepository repository,
IPropertySerializer propertySerializer) : base(repository)
{
_propertySerializer = propertySerializer;
}
public SourceSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
public RowSerializer(IPropertySerializer propertySerializer)
: base(propertySerializer)
{
}
/// <summary>
/// Custom serializer and deserializer
/// </summary>
/// <param name="serializer"></param>
/// <param name="deserializer"></param>
public SharpSerializer(IPropertySerializer serializer, IPropertyDeserializer deserializer)
{
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_deserializer = deserializer ?? throw new ArgumentNullException(nameof(deserializer));
}
