public void MatchesIdenticallyNamedParameter()
{
var param = AParamOfCConstructor();
var namedParam = new NamedParameter("a", new A());
Func<object> vp;
Assert.True(namedParam.CanSupplyValue(param, new Container(), out vp));
}
public void DoesNotMatchDifferentlyNamedParameter()
{
var param = AParamOfCConstructor();
var namedParam = new NamedParameter("b", new B());
Func<object> vp;
Assert.False(namedParam.CanSupplyValue(param, new Container(), out vp));
}
public IDialogOption GetDialogOption(string text, ITextConfig config = null, ITextConfig hoverConfig = null,
ITextConfig hasBeenChosenConfig = null, bool speakOption = true, bool showOnce = false)
{
var game = _resolver.Container.Resolve <IGame>();
if (config == null)
{
config = _fontLoader.GetTextConfig(autoFit: AutoFit.TextShouldWrapAndLabelShouldFitHeight,
brush: _brushLoader.LoadSolidBrush(Colors.White), font: _fontLoader.LoadFont(null, 10f));
}
if (hoverConfig == null)
{
hoverConfig = _fontLoader.GetTextConfig(autoFit: AutoFit.TextShouldWrapAndLabelShouldFitHeight,
brush: _brushLoader.LoadSolidBrush(Colors.Yellow), font: _fontLoader.LoadFont(null, 10f));
}
if (hasBeenChosenConfig == null)
{
hasBeenChosenConfig = _fontLoader.GetTextConfig(autoFit: AutoFit.TextShouldWrapAndLabelShouldFitHeight,
brush: _brushLoader.LoadSolidBrush(Colors.Gray), font: _fontLoader.LoadFont(null, 10f));
}
ILabel label = _ui.GetLabel($"Dialog option: {text}", text, game.Settings.VirtualResolution.Width, 20f, 0f, 0f,
config: config, addToUi: false);
label.Enabled = true;
TypedParameter labelParam = new TypedParameter(typeof(ILabel), label);
NamedParameter speakParam = new NamedParameter("speakOption", speakOption);
NamedParameter showOnceParam = new NamedParameter("showOnce", showOnce);
NamedParameter hoverParam = new NamedParameter("hoverConfig", hoverConfig);
NamedParameter wasChosenParam = new NamedParameter("hasBeenChosenConfig", hasBeenChosenConfig);
TypedParameter playerParam = new TypedParameter(typeof(ICharacter), _gameState.Player);
IDialogActions dialogActions = _resolver.Container.Resolve <IDialogActions>(playerParam);
TypedParameter dialogActionsParam = new TypedParameter(typeof(IDialogActions), dialogActions);
IDialogOption option = _resolver.Container.Resolve <IDialogOption>(labelParam, speakParam, showOnceParam, hoverParam,
wasChosenParam, playerParam, dialogActionsParam);
return(option);
}
public static IContainer Bind(this ContainerBuilder builder)
{
var configParameters = new NamedParameter[]
{
new NamedParameter("applicationName", ConfigSettings.ApplicationName),
new NamedParameter("connectionString", ConfigSettings.ConnectionString),
new NamedParameter("refreshTimerIntervalInMs", ConfigSettings.RefreshTimerIntervalInMs),
};
builder.RegisterType <ConfigurationReader>().As <IConfigurationReader>()
.WithParameters(configParameters).SingleInstance();
builder.RegisterType <ConfigurationContext>().As <IConfigurationContext>().SingleInstance();
builder.RegisterType <MongoDbConfig>();
var config = new ServerConfig();
builder.RegisterInstance(config);
builder.RegisterType <MongoConfigurationRepository>().As <IConfigurationRepository>();
return(builder.Build());
}
public void DecoratorRegisteredAsLambdaCanAcceptAdditionalParameters()
{
const string parameterName = "parameter";
const string parameterValue = "ABC";
var builder = new ContainerBuilder();
builder.RegisterType <ImplementorA>().As <IDecoratedService>();
builder.RegisterDecorator <IDecoratedService>((c, p, i) =>
{
var stringParameter = (string)p
.OfType <NamedParameter>()
.FirstOrDefault(np => np.Name == parameterName)?.Value;
return(new DecoratorWithParameter(i, stringParameter));
});
builder.RegisterDecorator <DecoratorA, IDecoratedService>();
var container = builder.Build();
var parameter = new NamedParameter(parameterName, parameterValue);
var instance = container.Resolve <IDecoratedService>(parameter);
Assert.Equal(parameterValue, ((DecoratorWithParameter)instance.Decorated).Parameter);
}
private static bool TryCreateVector3(INamedParameter xParam, INamedParameter yParam, INamedParameter zParam, IUnit linearUnit, out Vector3 result)
{
double x, y, z;
if (NamedParameter.TryGetDouble(xParam, out x) && NamedParameter.TryGetDouble(yParam, out y) && NamedParameter.TryGetDouble(zParam, out z))
{
if (null != linearUnit)
{
ConvertIfVaild(xParam.Unit, linearUnit, ref x);
ConvertIfVaild(yParam.Unit, linearUnit, ref y);
ConvertIfVaild(zParam.Unit, linearUnit, ref z);
}
result = new Vector3(x, y, z);
return(true);
}
result = Vector3.Invalid;
return(false);
}
/// <summary>
/// Return something which implements the type.
/// </summary>
/// <typeparam name="TContract"></typeparam>
/// <param name="namedParameter">Name/Value pair for passed parameters.</param>
/// <returns></returns>
public static TContract Resolve <TContract>(NamedParameter namedParameter)
{
return(_container.Resolve <TContract>(namedParameter));
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
position.x += 4;
position.width -= 6;
if (!initialized)
{
AIEditorWindow[] windows = Resources.FindObjectsOfTypeAll <AIEditorWindow>();
if (windows.Length > 0)
{
controller = windows[0].controller;
}
initialized = true;
}
if (controller != null)
{
NamedParameter param = (NamedParameter)property.objectReferenceValue;
if (param == null)
{
property.objectReferenceValue = param = CreateUserParameter();
}
position.width -= 15;
Rect r = new Rect(position);
r.x += position.width;
r.width = 20;
param.userVariable = GUI.Toggle(r, param.userVariable, GUIContent.none);
if (param != null && param.userVariable)
{
param.Name = string.Empty;
SerializedObject paramObject = new SerializedObject(param);
paramObject.Update();
EditorGUI.PropertyField(position, paramObject.FindProperty("value"), new GUIContent(label.text));
paramObject.ApplyModifiedProperties();
}
else
{
string[] parameters = null;
if (fieldInfo.FieldType == typeof(Vector3Parameter))
{
parameters = controller.GetParameterNames(fieldInfo.FieldType, typeof(GameObjectParameter));
}
else
{
parameters = controller.GetParameterNames(fieldInfo.FieldType);
}
if (parameters.Length == 0)
{
System.Array.Resize(ref parameters, parameters.Length + 1);
parameters[parameters.Length - 1] = "None";
List <string> list = new List <string>(parameters);
list.Swap(0, parameters.Length - 1);
parameters = list.ToArray();
}
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] == param.Name)
{
selectedIndex = i;
}
}
GUI.color = (parameters[selectedIndex] == "None"?Color.red:Color.white);
selectedIndex = EditorGUI.Popup(position, label.text, selectedIndex, parameters);
GUI.color = Color.white;
if (parameters[selectedIndex] != "None")
{
param.Name = parameters[selectedIndex];
}
}
}
}
public void Set(string name, ParameterType type, int elementCount, IntPtr value, int checkTotalSizeInBytes)
{
if (NamedParameters == null)
{
NamedParameters = new Dictionary <string, NamedParameter>(32);
}
if (string.IsNullOrEmpty(name))
{
Log.Fatal("ParameterContainer: Set: Name can't be empty.");
}
if (!ParameterTypeUtility.CanConvertToByteArray(type))
{
Log.Fatal("ParameterContainer: Set: !ParameterTypeUtils.CanConvertToByteArray( type )");
}
//ParameterItem parameter = null;
////use current parameter or new depending format
//{
// ParameterItem currentItem;
// if( parameters.TryGetValue( name, out currentItem ) )
// {
// if( type == currentItem.type && elementCount == currentItem.elementCount )
// {
// //!!!!!так?
// parameter = currentItem;
// }
// else
// Remove( name );
// }
//}
////create parameter
//if( parameter == null )
//{
// parameter = new ParameterItem();
// parameter.container = this;
// parameter.name = name;
// parameter.type = type;
// parameter.elementCount = elementCount;
// parameters[ name ] = parameter;
//}
var parameter = new NamedParameter();
parameter.Type = type;
parameter.ElementCount = elementCount;
if (parameter.GetTotalSizeInBytes() != checkTotalSizeInBytes)
{
Log.Fatal("ParameterContainer: Set: parameter.GetValueSizeInBytes() != checkTotalSizeInBytes.");
}
//prepare data array
//if( parameter.valueDataPosition == -1 )
{
int needSize = dataUsedBytes + parameter.GetTotalSizeInBytes();
if (data == null)
{
data = new byte[256];
}
if (needSize > data.Length)
{
int newSize = data.Length * 2;
while (newSize < needSize)
{
newSize *= 2;
}
byte[] newData = new byte[newSize];
Buffer.BlockCopy(data, 0, newData, 0, dataUsedBytes);
data = newData;
}
parameter.ValueDataPosition = dataUsedBytes;
dataUsedBytes += parameter.GetTotalSizeInBytes();
}
//copy value
unsafe
{
fixed(byte *pData = data)
NativeUtility.CopyMemory((IntPtr)(pData + parameter.ValueDataPosition), (IntPtr)value, parameter.GetTotalSizeInBytes());
}
if (NamedParameters == null)
{
NamedParameters = new Dictionary <string, NamedParameter>(32);
}
NamedParameters[name] = parameter;
unchecked
{
version++;
}
//return parameter;
}
public NamedParameter AddParameter(object value, IType type)
{
var parameter = new NamedParameter("p" + (_parameters.Count + 1), value, type);
_parameters.Add(parameter);
return parameter;
}
private void RegisterRepositories(ContainerBuilder builder)
{
if (_settings.CurrentValue.Db.StorageMode == StorageMode.SqlServer)
{
if (string.IsNullOrEmpty(_settings.CurrentValue.Db.DataConnString))
{
throw new Exception($"{nameof(_settings.CurrentValue.Db.DataConnString)} must have a value if StorageMode is SqlServer");
}
var connstrParameter = new NamedParameter("connectionString",
_settings.CurrentValue.Db.DataConnString);
builder.RegisterType <SqlLogRepository>()
.As <ILogRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.AssetsRepository>()
.As <IAssetsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.TradingRoutesRepository>()
.As <ITradingRoutesRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.OperationExecutionInfoRepository>()
.As <IOperationExecutionInfoRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.BlobRepository>()
.As <IMarginTradingBlobRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.AuditRepository>()
.As <IAuditRepository>()
.SingleInstance();
builder.RegisterType <SqlRepos.ClientProfilesRepository>()
.As <IClientProfilesRepository>()
.SingleInstance();
builder.RegisterSingletonIfNotRegistered <SqlRepos.AssetTypesRepository, IAssetTypesRepository>();
builder.RegisterType <SqlRepos.ClientProfileSettingsRepository>()
.As <IClientProfileSettingsRepository>()
.SingleInstance();
builder.RegisterType <SqlRepos.ProductsRepository>()
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType <SqlRepos.MarketSettingsRepository>()
.As <IMarketSettingsRepository>()
.SingleInstance();
builder.RegisterType <SqlRepos.CurrenciesRepository>()
.AsImplementedInterfaces()
.SingleInstance();
builder.RegisterType <SqlRepos.TickFormulaRepository>()
.As <ITickFormulaRepository>()
.SingleInstance();
builder.RegisterType <SqlRepos.ProductCategoriesRepository>()
.AsImplementedInterfaces()
.SingleInstance();
}
else if (_settings.CurrentValue.Db.StorageMode == StorageMode.Azure)
{
if (string.IsNullOrEmpty(_settings.CurrentValue.Db.DataConnString))
{
throw new Exception("AzureConnectionString must have a value if StorageMode is Azure");
}
var connstrParameter = new NamedParameter("connectionStringManager",
_settings.Nested(x => x.Db.DataConnString));
builder.RegisterType <AzureRepos.TradingRoutesRepository>()
.As <ITradingRoutesRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.OperationExecutionInfoRepository>()
.As <IOperationExecutionInfoRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.BlobRepository>()
.As <IMarginTradingBlobRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
}
}
public void Set(string name, object value, ParameterType type = ParameterType.Unknown, int elementCount = 0)
{
if (string.IsNullOrEmpty(name))
{
Log.Fatal("ParameterContainer: Set: Name can't be empty.");
}
if (value == null)
{
Log.Fatal("ParameterContainer: Set: value == null.");
}
//detect elementCount
if (elementCount == 0)
{
if (value.GetType().IsArray)
{
Array array = (Array)value;
elementCount = array.GetLength(0);
}
else
{
elementCount = 1;
}
}
//detect type
if (type == ParameterType.Unknown)
{
Type elementType = null;
{
if (value.GetType().IsArray)
{
elementType = value.GetType().GetElementType();
}
else
{
elementType = value.GetType();
}
}
//!!!!!reference values in array
type = ParameterTypeUtility.DetectTypeByClassType(elementType);
//!!!!было
////!!!!!так?
////detect texture type by the value
//if( type == ParameterType.Unknown )
//{
// GpuMaterialPass.TextureParameterValue textureValue = null;
// if( value.GetType().IsArray )
// {
// Array array = (Array)value;
// if( array.GetLength( 0 ) > 0 )
// textureValue = array.GetValue( 0 ) as GpuMaterialPass.TextureParameterValue;
// }
// else
// textureValue = value as GpuMaterialPass.TextureParameterValue;
// if( textureValue != null && textureValue.Texture != null )
// {
// var gpuTexture = textureValue.Texture.Result;
// if( gpuTexture != null )
// {
// switch( gpuTexture.TextureType )
// {
// //case Component_Texture.TypeEnum._1D: type = ParameterType.Texture1D; break;
// case Component_Image.TypeEnum._2D: type = ParameterType.Texture2D; break;
// case Component_Image.TypeEnum._3D: type = ParameterType.Texture3D; break;
// case Component_Image.TypeEnum.Cube: type = ParameterType.TextureCube; break;
// }
// }
// }
//}
}
//!!!!!check for invalid data
//ParameterItem parameter = null;
////use current parameter or new depending format
//{
// ParameterItem currentItem;
// if( parameters.TryGetValue( name, out currentItem ) )
// {
// if( type == currentItem.type && elementCount == currentItem.elementCount )
// {
// //!!!!!так?
// parameter = currentItem;
// }
// else
// Remove( name );
// }
//}
////create parameter
//if( parameter == null )
//{
// parameter = new ParameterItem();
// parameter.container = this;
// parameter.name = name;
// parameter.type = type;
// parameter.elementCount = elementCount;
// parameters[ name ] = parameter;
//}
var parameter = new NamedParameter();
parameter.Type = type;
parameter.ElementCount = elementCount;
//update value
if (ParameterTypeUtility.CanConvertToByteArray(type))
{
//prepare data array
//if( parameter.valueDataPosition == -1 )
{
int needSize = dataUsedBytes + parameter.GetTotalSizeInBytes();
if (data == null)
{
data = new byte[256];
}
if (needSize > data.Length)
{
int newSize = data.Length * 2;
while (newSize < needSize)
{
newSize *= 2;
}
byte[] newData = new byte[newSize];
Buffer.BlockCopy(data, 0, newData, 0, dataUsedBytes);
data = newData;
}
parameter.ValueDataPosition = dataUsedBytes;
dataUsedBytes += parameter.GetTotalSizeInBytes();
}
//copy value
unsafe
{
fixed(byte *pData = data)
{
//!!!!slowly
if (value.GetType().IsArray)
{
byte *pDest = pData + parameter.ValueDataPosition;
int elementSize = ParameterTypeUtility.GetElementSizeInBytes(parameter.Type);
foreach (var item in (IList)value)
{
Marshal.StructureToPtr(item, (IntPtr)pDest, false);
pDest += elementSize;
}
}
else
{
Marshal.StructureToPtr(value, (IntPtr)(pData + parameter.ValueDataPosition), false);
}
}
}
}
else
{
parameter.ValueReference = value;
}
if (NamedParameters == null)
{
NamedParameters = new Dictionary <string, NamedParameter>(32);
}
NamedParameters[name] = parameter;
unchecked
{
version++;
}
//return parameter;
}
public override T VisitNamedParameter(NamedParameter node)
{
throw new NotImplementedException();
}
public IServiceRunner Create(RunMode runMode)
{
var parameter = new NamedParameter(HostModule.RUN_MODE_PARAMETER, runMode);
return(ContainerProvider.Instance.ApplicationContainer.Resolve <IServiceRunner>(parameter));
}
private void RegisterRepositories(ContainerBuilder builder)
{
if (_settings.CurrentValue.Db.StorageMode == StorageMode.SqlServer)
{
if (string.IsNullOrEmpty(_settings.CurrentValue.Db.DataConnString))
{
throw new Exception($"{nameof(_settings.CurrentValue.Db.DataConnString)} must have a value if StorageMode is SqlServer");
}
var connstrParameter = new NamedParameter("connectionString",
_settings.CurrentValue.Db.DataConnString);
builder.RegisterType <SqlLogRepository>()
.As <ILogRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.AssetPairsRepository>()
.As <IAssetPairsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.AssetsRepository>()
.As <IAssetsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.MarketRepository>()
.As <IMarketRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.ScheduleSettingsRepository>()
.As <IScheduleSettingsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.TradingConditionsRepository>()
.As <ITradingConditionsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.TradingInstrumentsRepository>()
.As <ITradingInstrumentsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.TradingRoutesRepository>()
.As <ITradingRoutesRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <SqlRepos.OperationExecutionInfoRepository>()
.As <IOperationExecutionInfoRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
}
else if (_settings.CurrentValue.Db.StorageMode == StorageMode.Azure)
{
if (string.IsNullOrEmpty(_settings.CurrentValue.Db.DataConnString))
{
throw new Exception("AzureConnectionString must have a value if StorageMode is Azure");
}
var connstrParameter = new NamedParameter("connectionStringManager",
_settings.Nested(x => x.Db.DataConnString));
builder.RegisterType <AzureRepos.AssetPairsRepository>()
.As <IAssetPairsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.AssetsRepository>()
.As <IAssetsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.MarketRepository>()
.As <IMarketRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.ScheduleSettingsRepository>()
.As <IScheduleSettingsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.TradingConditionsRepository>()
.As <ITradingConditionsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.TradingInstrumentsRepository>()
.As <ITradingInstrumentsRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.TradingRoutesRepository>()
.As <ITradingRoutesRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
builder.RegisterType <AzureRepos.OperationExecutionInfoRepository>()
.As <IOperationExecutionInfoRepository>()
.WithParameter(connstrParameter)
.SingleInstance();
}
}
protected override void InitializeParameter(System.Data.IDbDataParameter p, NamedParameter parameter, object value)
{
p.ParameterName = parameter.Name;
p.Value = value ?? DBNull.Value;
var sqlType = parameter.SqlType;
if (parameter.SqlType != null)
{
if (sqlType.Length > 0)
{
p.Size = sqlType.Length;
}
if (sqlType.Precision > 0)
{
p.Precision = sqlType.Precision;
}
if (sqlType.Scale > 0)
{
p.Scale = sqlType.Scale;
}
if (sqlType.Required)
{
(p as DbParameter).IsNullable = false;
}
switch (sqlType.DbType)
{
case DBType.NChar:
case DBType.NVarChar:
{
var str = value as string;
if (string.IsNullOrEmpty(str))
{
p.Size = 2;
}
else
{
p.Size = str.Length * 2;
}
break;
}
case DBType.Char:
case DBType.VarChar:
{
var str = value as string;
if (string.IsNullOrEmpty(str))
{
p.Size = 1;
}
else
{
p.Size = str.Length * 1;
}
break;
}
case DBType.Guid:
parameter.sqlType = SqlType.Get(DBType.Binary, 16);
if (value is Guid)
{
p.Value = ((Guid)value).ToByteArray();
}
else if (value != null)
{
p.Value = (((Guid?)value).Value).ToByteArray();
}
break;
case DBType.Binary:
case DBType.Image:
if (value is Guid)
{
p.Value = ((Guid)value).ToByteArray();
parameter.sqlType = SqlType.Get(DBType.Binary, 16);
}
else if (value is Guid?)
{
p.Value = ((Guid?)value).Value.ToByteArray();
parameter.sqlType = SqlType.Get(DBType.Binary, 16);
}
break;
}
}
ConvertDBTypeToNativeType(p, parameter.sqlType.DbType);
}
protected void InitializeParameter(OracleParameter p, NamedParameter parameter, object value)
{
p.ParameterName = parameter.Name;
p.Value = value ?? DBNull.Value;
var sqlType = parameter.SqlType;
if (parameter.SqlType != null)
{
if (sqlType.Length > 0)
{
p.Size = sqlType.Length;
}
if (sqlType.Precision > 0)
{
p.Precision = sqlType.Precision;
}
if (sqlType.Scale > 0)
{
p.Scale = sqlType.Scale;
}
if (sqlType.Required)
{
(p as DbParameter).IsNullable = false;
}
switch (sqlType.DbType)
{
case DBType.NChar:
case DBType.NVarChar:
{
var str = value as string;
if (!string.IsNullOrEmpty(str))
{
p.Size = str.Length;
int count = Encoding.Default.GetByteCount(str);
if (chinaRegix.IsMatch(str) && count > 4000 && str.Length <= 4000)
{
//p.Size = 2000;
p.Value = str.Substring(2000);
}
}
break;
}
case DBType.Char:
case DBType.VarChar:
{
var str = value as string;
if (string.IsNullOrEmpty(str))
{
p.Size = 1;
}
else
{
p.Size = str.Length * 1;
}
break;
}
case DBType.Guid:
parameter.sqlType = SqlType.Get(DBType.Binary, 16);
if (value is Guid)
{
p.Value = ((Guid)value).ToByteArray();
}
else if (value != null)
{
p.Value = (((Guid?)value).Value).ToByteArray();
}
break;
case DBType.Binary:
case DBType.Image:
if (value is Guid)
{
p.Value = ((Guid)value).ToByteArray();
parameter.sqlType = SqlType.Get(DBType.Binary, 16);
}
else if (value is Guid?)
{
p.Value = ((Guid?)value).Value.ToByteArray();
parameter.sqlType = SqlType.Get(DBType.Binary, 16);
}
break;
}
}
ConvertDBTypeToNativeType(p, parameter.sqlType.DbType);
}
private void RegisterCandlesServices(ContainerBuilder builder)
{
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterType <RabbitMqSubscribersFactory>()
.As <IRabbitMqSubscribersFactory>();
// Optionally loading quotes subscriber if it is present in settings...
if (_settings.Rabbit.QuotesSubscribtion != null)
{
if (_quotesSourceType == QuotesSourceType.Spot)
{
_services.AddSingleton <IRabbitPoisonHandingService <QuoteMessage> >(provider => new RabbitPoisonHandingService <QuoteMessage>(
provider.GetService <ILog>(),
provider.GetService <IQuotesSubscriber>().SubscriptionSettings));
_services.AddSingleton <IQuotesPoisonHandingService>(provider => new QuotesPoisonHandingService <QuoteMessage>(
provider.GetService <IRabbitPoisonHandingService <QuoteMessage> >()));
builder.RegisterType <SpotQuotesSubscriber>()
.As <IQuotesSubscriber>()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.Rabbit.QuotesSubscribtion))
.WithParameter(TypedParameter.From(_settings.SkipEodQuote));
}
else
{
_services.AddSingleton <IRabbitPoisonHandingService <MtQuoteMessage> >(provider => new RabbitPoisonHandingService <MtQuoteMessage>(
provider.GetService <ILog>(),
provider.GetService <IQuotesSubscriber>().SubscriptionSettings));
_services.AddSingleton <IQuotesPoisonHandingService>(provider => new QuotesPoisonHandingService <MtQuoteMessage>(
provider.GetService <IRabbitPoisonHandingService <MtQuoteMessage> >()));
builder.RegisterType <MtQuotesSubscriber>()
.As <IQuotesSubscriber>()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.Rabbit.QuotesSubscribtion))
.WithParameter(TypedParameter.From(_settings.SkipEodQuote));
}
}
else
{
_services.AddSingleton <IRabbitPoisonHandingService <EmptyQuote> >(provider => new RabbitPoisonHandingService <EmptyQuote>(
provider.GetService <ILog>(),
provider.GetService <IQuotesSubscriber>().SubscriptionSettings));
_services.AddSingleton <IQuotesPoisonHandingService>(provider => new QuotesPoisonHandingService <EmptyQuote>(
provider.GetService <IRabbitPoisonHandingService <EmptyQuote> >()));
builder.RegisterType <EmptyQuotesSubscriber>()
.As <IQuotesSubscriber>()
.SingleInstance();
}
if (_quotesSourceType == QuotesSourceType.Spot)
{
_services.AddSingleton <IRabbitPoisonHandingService <LimitOrdersMessage> >(provider => new RabbitPoisonHandingService <LimitOrdersMessage>(
provider.GetService <ILog>(),
provider.GetService <ITradesSubscriber>().SubscriptionSettings));
_services.AddSingleton <ITradesPoisonHandingService>(provider => new TradesPoisonHandingService <LimitOrdersMessage>(
provider.GetService <IRabbitPoisonHandingService <LimitOrdersMessage> >()));
builder.RegisterType <SpotTradesSubscriber>()
.As <ITradesSubscriber>()
.SingleInstance()
.WithParameter(TypedParameter.From <IRabbitSubscriptionSettings>(_settings.Rabbit.TradesSubscription));
}
else
{
_services.AddSingleton <IRabbitPoisonHandingService <MtTradeMessage> >(provider => new RabbitPoisonHandingService <MtTradeMessage>(
provider.GetService <ILog>(),
provider.GetService <ITradesSubscriber>().SubscriptionSettings));
_services.AddSingleton <ITradesPoisonHandingService>(provider => new TradesPoisonHandingService <MtTradeMessage>(
provider.GetService <IRabbitPoisonHandingService <MtTradeMessage> >()));
builder.RegisterType <MtTradesSubscriber>()
.As <ITradesSubscriber>()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.Rabbit.TradesSubscription.ConnectionString))
.WithParameter(TypedParameter.From(_settings.CandlesGenerator.GenerateTrades));
}
builder.RegisterType <MidPriceQuoteGenerator>()
.As <IMidPriceQuoteGenerator>()
.As <IHaveState <IImmutableDictionary <string, IMarketState> > >()
.SingleInstance();
builder.RegisterType <CandlesGenerator>()
.As <ICandlesGenerator>()
.As <IHaveState <ImmutableDictionary <string, ICandle> > >()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.CandlesGenerator.OldDataWarningTimeout));
builder.RegisterType <CandlesManager>()
.As <ICandlesManager>()
.WithParameter(TypedParameter.From(_settings.CandlesGenerator.TimeIntervals))
.WithParameter(TypedParameter.From(_settings.CandlesGenerator.GenerateBidAndAsk));
if (_settings.Db.StorageMode == StorageMode.SqlServer)
{
var connstrParameter = new NamedParameter("connectionString",
_settings.Db.SnapshotsConnectionString);
builder.Register <ISnapshotRepository <IImmutableDictionary <string, IMarketState> > >(ctx =>
new SqlMidPriceQuoteGeneratorSnapshotRepository(_settings.Db.SnapshotsConnectionString))
.SingleInstance();
builder.RegisterType <SnapshotSerializer <IImmutableDictionary <string, IMarketState> > >()
.As <ISnapshotSerializer>();
builder.Register <ISnapshotRepository <ImmutableDictionary <string, ICandle> > >(ctx =>
new SqlCandlesGeneratorSnapshotRepository(_settings.Db.SnapshotsConnectionString))
.SingleInstance();
builder.RegisterType <SnapshotSerializer <ImmutableDictionary <string, ICandle> > >()
.As <ISnapshotSerializer>();
}
else if (_settings.Db.StorageMode == StorageMode.Azure)
{
var snapshotsConnStringManager = _dbSettings.ConnectionString(x => x.SnapshotsConnectionString);
builder.RegisterType <MidPriceQuoteGeneratorSnapshotRepository>()
.As <ISnapshotRepository <IImmutableDictionary <string, IMarketState> > >()
.WithParameter(TypedParameter.From(AzureBlobStorage.Create(snapshotsConnStringManager, maxExecutionTimeout: TimeSpan.FromMinutes(5))));
builder.RegisterType <SnapshotSerializer <IImmutableDictionary <string, IMarketState> > >()
.As <ISnapshotSerializer>();
builder.RegisterType <CandlesGeneratorSnapshotRepository>()
.As <ISnapshotRepository <ImmutableDictionary <string, ICandle> > >()
.WithParameter(TypedParameter.From(AzureBlobStorage.Create(snapshotsConnStringManager, maxExecutionTimeout: TimeSpan.FromMinutes(5))))
.SingleInstance();
builder.RegisterType <SnapshotSerializer <ImmutableDictionary <string, ICandle> > >()
.As <ISnapshotSerializer>()
.PreserveExistingDefaults();
}
}
/// <summary>
/// method returns the Data
/// </summary>
public async void ReceiveData(Message message)
{
// locals
User user = null;
bool refreshRequired = false;
// If the message object exists
if (NullHelper.Exists(message))
{
// if this is a Check Unique request
if (TextHelper.IsEqual(message.Text, "Check Unique"))
{
// if there are at least one parameter
if (ListHelper.HasOneOrMoreItems(message.Parameters))
{
// if User Name
if ((TextHelper.IsEqual(message.Parameters[0].Name, "User Name")) && (NullHelper.Exists(message.Parameters[0].Value)))
{
// get the userName
string userName = message.Parameters[0].Value.ToString();
// attempt to find the UserName
user = await UserService.FindUserByUserName(userName);
// if the user exists
if (HasUserNameComponent)
{
// create a response
Message response = new Message();
// if the user exists
if (NullHelper.Exists(user))
{
// set to true
refreshRequired = true;
// Send a response of Taken
response.Text = "Taken";
// Create the parameters
NamedParameter namedParameter = new NamedParameter();
// Set the name
namedParameter.Name = "Validation Message";
// Set the value
namedParameter.Value = "The User Name is already taken. Click the login button if this is you.";
// Set the ValidationMessage
this.ValidationMessage = namedParameter.Value.ToString();
// Add the parameter
response.Parameters.Add(namedParameter);
}
else
{
// Send a response of Taken
response.Text = "Available";
}
// send a message to the user
UserNameComponent.ReceiveData(response);
// Not valid
UserNameComponent.IsValid = false;
}
}
//if EmailAddress
else if ((TextHelper.IsEqual(message.Parameters[0].Name, "Email Address")) && (NullHelper.Exists(message.Parameters[0].Value)))
{
// get the email
string email = message.Parameters[0].Value.ToString();
// attempt to find the UserName
user = await UserService.FindUserByEmailAddress(email);
// if the value for HasEmailAddressComponent is true
if (HasEmailAddressComponent)
{
// create a response
Message response = new Message();
// if the user exists
if (NullHelper.Exists(user))
{
// set to true
refreshRequired = true;
// Send a response of Taken
response.Text = "Taken";
// Create the parameters
NamedParameter namedParameter = new NamedParameter();
// Set the name
namedParameter.Name = "Validation Message";
// Set the value
namedParameter.Value = "This email address is already taken. Click the Login Button if this is you.";
// set the ValidationMessage
this.ValidationMessage = namedParameter.Value.ToString();
// Add the parameter
response.Parameters.Add(namedParameter);
// Not valid
EmailAddressComponent.IsValid = false;
}
else
{
// Send a response of Available
response.Text = "Available";
// Not valid
EmailAddressComponent.IsValid = true;
}
// send a message to the user
EmailAddressComponent.ReceiveData(response);
}
}
}
}
}
if (refreshRequired)
{
// update the UI
Refresh();
}
}
public static void InjectProperties(IComponentContext context, object instance, IPropertySelector propertySelector, IEnumerable <Parameter> parameters)
{
//判断instance是否是代理类型，如果是代理类型，则取Target
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (propertySelector == null)
{
throw new ArgumentNullException(nameof(propertySelector));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var unproxyedInstance = UnwrapProxy(instance);
var instanceType = instance.GetType();
var unproxyedInstanceType = unproxyedInstance.GetType();
foreach (var property in unproxyedInstanceType
.GetRuntimeProperties()
.Where(pi => pi.CanWrite))
{
var propertyType = property.PropertyType;
if (propertyType.GetTypeInfo().IsValueType&& !propertyType.GetTypeInfo().IsEnum)
{
continue;
}
if (propertyType.IsArray && propertyType.GetElementType().GetTypeInfo().IsValueType)
{
continue;
}
if (propertyType.IsGenericEnumerableInterfaceType() && propertyType.GetTypeInfo().GenericTypeArguments[0].GetTypeInfo().IsValueType)
{
continue;
}
if (property.GetIndexParameters().Length != 0)
{
continue;
}
if (!propertySelector.InjectProperty(property, instance))
{
continue;
}
var setParameter = property.SetMethod.GetParameters().First();
var valueProvider = (Func <object>)null;
var parameter = parameters.FirstOrDefault(p => p.CanSupplyValue(setParameter, context, out valueProvider));
if (parameter != null)
{
property.SetValue(unproxyedInstance, valueProvider(), null);
continue;
}
object propertyValue;
var propertyService = new TypedService(propertyType);
var instanceTypeParameter = new NamedParameter(InstanceTypeNamedParameter, unproxyedInstanceType);
if (context.TryResolveService(propertyService, new Parameter[] { instanceTypeParameter }, out propertyValue))
{
property.SetValue(unproxyedInstance, propertyValue, null);
}
}
}
public TService Resolve <TService>(NamedParameter namedParameter)
{
return(_container.Resolve <TService>());
}
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateMolodenskyBadekas(TransformationCompilationParams opData)
{
Contract.Requires(opData != null);
var xTransParam = new KeywordNamedParameterSelector("XAXIS", "TRANS");
var yTransParam = new KeywordNamedParameterSelector("YAXIS", "TRANS");
var zTransParam = new KeywordNamedParameterSelector("ZAXIS", "TRANS");
var xRotParam = new KeywordNamedParameterSelector("XAXIS", "ROT");
var yRotParam = new KeywordNamedParameterSelector("YAXIS", "ROT");
var zRotParam = new KeywordNamedParameterSelector("ZAXIS", "ROT");
var scaleParam = new KeywordNamedParameterSelector("SCALE");
var ord1Param = new KeywordNamedParameterSelector("ORDINATE1");
var ord2Param = new KeywordNamedParameterSelector("ORDINATE2");
var ord3Param = new KeywordNamedParameterSelector("ORDINATE3");
if (!opData.ParameterLookup.Assign(xTransParam, yTransParam, zTransParam, xRotParam, yRotParam, zRotParam, scaleParam, ord1Param, ord2Param, ord3Param))
{
return(null);
}
Vector3 translation, rotation;
Point3 ordinate;
double scale;
if (!TryCreateVector3(xTransParam.Selection, yTransParam.Selection, zTransParam.Selection, out translation))
{
return(null);
}
if (!TryCreateVector3(xRotParam.Selection, yRotParam.Selection, zRotParam.Selection, OgcAngularUnit.DefaultRadians, out rotation))
{
return(null);
}
if (!TryCreatePoint3(ord1Param.Selection, ord2Param.Selection, ord3Param.Selection, out ordinate))
{
return(null);
}
if (!NamedParameter.TryGetDouble(scaleParam.Selection, out scale))
{
return(null);
}
var molodensky = new MolodenskyBadekasTransformation(translation, rotation, ordinate, scale);
if (opData.StepParams.RelatedInputCrs is ICrsGeocentric && opData.StepParams.RelatedOutputCrs is ICrsGeocentric)
{
return(new StaticCoordinateOperationCompiler.StepCompilationResult(
opData.StepParams,
opData.StepParams.RelatedOutputCrsUnit ?? opData.StepParams.RelatedInputCrsUnit ?? opData.StepParams.InputUnit,
molodensky));
}
// TODO: need to handle units here
var spheroidFrom = opData.StepParams.RelatedInputSpheroid;
if (null == spheroidFrom)
{
return(null);
}
// TODO: need to handle units here
var spheroidTo = opData.StepParams.RelatedOutputSpheroid;
if (null == spheroidTo)
{
return(null);
}
ITransformation transformation = new GeocentricTransformationGeographicWrapper(spheroidFrom, spheroidTo, molodensky);
var conv = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultRadians);
if (null != conv)
{
transformation = new ConcatenatedTransformation(new[] { conv, transformation });
}
return(new StaticCoordinateOperationCompiler.StepCompilationResult(
opData.StepParams,
OgcAngularUnit.DefaultRadians,
transformation));
}
public async Task PushWithParameterAsync <TViewModel>(NamedParameter parameter) where TViewModel : BaseVM
{
Page view = _viewFactory.ResolveWithParameter <TViewModel>(parameter);
await Navigation.PushAsync(view);
}
private void DrawCustomParameters()
{
GUILayout.BeginArea(new Rect(scroll.x, scroll.y + position.height - 500, 200, 500));
GUILayout.FlexibleSpace();
bool state = EditorPrefs.GetBool("Parameters", false);
Rect rect = GUILayoutUtility.GetRect(new GUIContent("Parameters"), "flow overlay header lower left", GUILayout.ExpandWidth(true));
Rect rect2 = new Rect(rect.x + 175, rect.y + 2, 25, 25);
if (GUI.Button(rect2, "", "label"))
{
GenericMenu genericMenu = new GenericMenu();
IEnumerable <Type> types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly => assembly.GetTypes()).Where(type => type.IsSubclassOf(typeof(NamedParameter)));
foreach (Type type in types)
{
genericMenu.AddItem(new GUIContent(type.ToString().Split('.').Last().Replace("Parameter", "")), false, new GenericMenu.MenuFunction2(this.OnCreateParameter), type);
}
genericMenu.ShowAsContext();
}
if (GUI.Button(rect, "Parameters", "flow overlay header lower left"))
{
EditorPrefs.SetBool("Parameters", !state);
}
GUI.Label(rect2, iconToolbarPlus);
if (state)
{
EditorGUIUtility.labelWidth = 80;
GUILayout.BeginVertical((GUIStyle)"PopupCurveSwatchBackground", GUILayout.Width(199));
int deleteIndex = -1;
if (controller.parameters.Count > 0)
{
for (int i = 0; i < controller.parameters.Count; i++)
{
NamedParameter parameter = controller.parameters[i];
GUILayout.BeginHorizontal();
parameter.Name = EditorGUILayout.TextField(parameter.Name);
if (parameter.GetType() == typeof(BoolParameter))
{
GUILayout.FlexibleSpace();
BoolParameter boolParam = parameter as BoolParameter;
boolParam.Value = EditorGUILayout.Toggle(boolParam.Value, GUILayout.Width(14));
}
else if (parameter.GetType() == typeof(TagParameter))
{
TagParameter tagParam = parameter as TagParameter;
tagParam.Value = EditorGUILayout.TagField(tagParam.Value, GUILayout.Width(80));
}
else
{
SerializedObject paramObject = new SerializedObject(parameter);
paramObject.Update();
EditorGUILayout.PropertyField(paramObject.FindProperty("value"), GUIContent.none, GUILayout.Width(80));
paramObject.ApplyModifiedProperties();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button(iconToolbarMinus, "label"))
{
deleteIndex = i;
}
GUILayout.EndHorizontal();
}
}
else
{
GUILayout.Label("List is Empty");
}
if (deleteIndex != -1)
{
DestroyImmediate(controller.parameters[deleteIndex], true);
controller.parameters.RemoveAt(deleteIndex);
AssetDatabase.SaveAssets();
}
GUILayout.EndVertical();
}
GUILayout.EndArea();
}
public async Task PushAsyncWithParameter <TViewModel>(NamedParameter parameter) where TViewModel : class, IViewModel
{
var view = _viewFactory.ResolveWithParameter <TViewModel>(parameter);
await Navigation.PushAsync(view);
}
