public void MakeBinaryWithOperandConversion_LeftOperand_LiftedToTypeOfRight()
{
var left = Expression.Constant(0, typeof(int));
var right = Expression.Constant(0, typeof(int?));
var result = ConversionUtility.MakeBinaryWithOperandConversion(ExpressionType.Equal, left, right, false, null);
var expectedExpression = BinaryExpression.Equal(Expression.Convert(left, typeof(int?)), right);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public string ToString(FieldInfo fieldInfo, bool showRaw)
{
if (fieldInfo.delta)
{
float scale = NetworkConfig.decoderPrecisionScales[fieldInfo.precision];
return("(" + ((int)m_ValueX * scale) + ", " + ((int)m_ValueY * scale) + ", " + ((int)m_ValueZ * scale) + ", " + ((int)m_ValueW * scale) + ")");
}
else
{
return("(" + ConversionUtility.UInt32ToFloat(m_ValueX) + ", " + ConversionUtility.UInt32ToFloat(m_ValueY) + ", " + ConversionUtility.UInt32ToFloat(m_ValueZ) + ", " + ConversionUtility.UInt32ToFloat(m_ValueW) + ")");
}
}
/// <summary>
/// Get boolean value from application configuration.
/// </summary>
/// <param name="key"></param>
/// <param name="defaultValue"></param>
/// <returns></returns>
public static bool GetBoolean
(
string key,
bool defaultValue)
{
string s = CM.AppSettings [key];
if (!string.IsNullOrEmpty(s))
{
defaultValue = ConversionUtility.ToBoolean(s);
}
return(defaultValue);
}
public IHttpActionResult GetAuthors()
{
var authors = _context.Authors.ToList();
if (authors == null)
{
return(NotFound());
}
var authorDtos = ConversionUtility.AuthorsToAuthorDtos(authors);
return(Ok(authorDtos));
}
public IHttpActionResult GetAuthor(int id)
{
var author = _context.Authors.SingleOrDefault(a => a.Id == id);
if (author == null)
{
return(NotFound());
}
AuthorDto authorDto = ConversionUtility.AuthorToAuthorDto(author);
return(Ok(authorDto));
}
public async Task SetValueAsync(IDeferredItem <TItem> item, object deserializedValue, IDataTransaction dataTransaction)
{
await item.LoadAsync();
if (item.LoadedItem == null)
{
throw new ArgumentNullException(nameof(item.LoadedItem), "Cannot set field value for this item because the item is null.");
}
object convertedValue = ConversionUtility.ConvertValue(deserializedValue, _propertyInfo.PropertyType);
_propertyInfo.SetValue(item.LoadedItem, convertedValue);
}
public Expression <Func <TItem, bool> > GetPredicate(string identifier)
{
try
{
TReturn convertedIdentifier = ConversionUtility.ConvertString <TReturn>(identifier);
return(_predicateGetter(convertedIdentifier));
}
catch (Exception ex) when(ex is FormatException || ex is InvalidCastException)
{
// TODO hiding exception.. includes FormatException thrown in ConversionUtility
return(null);
}
}
public IHttpActionResult GetBook(int id)
{
var book = _context.Books.Include(b => b.Author).SingleOrDefault(b => b.Id == id);
if (book == null)
{
return(NotFound());
}
var bookDto = ConversionUtility.BookToBookDto(book);
return(Ok(bookDto));
}
public IHttpActionResult GetBooks()
{
var books = _context.Books.Include(b => b.Author).ToList();
if (books == null)
{
return(NotFound());
}
var bookDtos = ConversionUtility.BooksToBookDtos(books);
return(Ok(bookDtos));
}
public BitmapSource Render(Camera camera)
{
// Setup for rendering.
var rasterizerState = RasterizerState.New(_device, new RasterizerStateDescription
{
CullMode = CullMode.Back,
FillMode = FillMode.Solid,
IsMultisampleEnabled = true,
IsFrontCounterClockwise = Options.TriangleWindingOrderReversed
});
_device.SetRasterizerState(rasterizerState);
_device.Clear(_renderTexture, ConversionUtility.ToSharpDXColor(Options.BackgroundColor));
_device.Clear(_depthStencilTexture, DepthStencilClearFlags.Depth, 1, 0);
_device.SetRenderTargets(_depthStencilTexture, _renderTexture);
_effect.LightingEnabled = Options.LightingEnabled;
_effect.View = ConversionUtility.ToSharpDXMatrix(camera.GetViewMatrix());
_effect.Projection = ConversionUtility.ToSharpDXMatrix(camera.GetProjectionMatrix(_aspectRatio));
// Render scene.
_device.SetBlendState(_device.BlendStates.Opaque);
foreach (WarpMesh mesh in _meshes.Where(m => m.IsOpaque))
{
mesh.Draw(_effect);
}
_device.SetBlendState(_device.BlendStates.AlphaBlend);
foreach (WarpMesh mesh in _meshes.Where(m => !m.IsOpaque))
{
mesh.Draw(_effect);
}
_device.SetBlendState(null);
// Extract image from render target.
_device.SetRenderTargets((RenderTargetView)null);
_device.SetRasterizerState(null);
rasterizerState.Dispose();
using (var memoryStream = new MemoryStream())
{
_renderTexture.Save(memoryStream, ImageFileType.Png);
var bi = new BitmapImage();
bi.BeginInit();
bi.CacheOption = BitmapCacheOption.OnLoad;
bi.StreamSource = memoryStream;
bi.EndInit();
return(bi);
}
}
static void Main(string[] args)
{
//foreach (var arg in args)
//{
bool passed = false;
DateTime start = DateTime.Now;
List <Provider> providerList = new List <Provider>();
StringBuilder str = new StringBuilder();
Console.WriteLine("Starting...");
try
{
//if (arg.Equals("-f"))
//{
providerList = ProviderDBReader.GetFLProviders();
//}
//else if (arg.Equals("-h"))
//{
// providerList = ProviderDBReader.GetHIProviders();
//}
//else
//{
// Console.WriteLine("Option passed is not a valid argument.");
// return;
//}
Console.WriteLine("Flattening data...");
providerList = ConversionUtility.Flatten(providerList);
Console.WriteLine("Converting to JSON...");
Console.WriteLine("Starting file write...");
passed = new JSONFileWriter(
ConfigurationManager.AppSettings["JSONProviders_FL"])
.WriteProviderFile(providerList);
}
catch (Exception)
{
passed = false;
}
double duration = DateTime.Now.Subtract(start).TotalSeconds;
Console.WriteLine("Process " + (passed ? "COMPLETED" : "FAILED") + " in "
+ duration + " seconds.");
Console.Write("Press any key to continue. ");
Console.ReadKey();
//}
}
public static bool HasCompatibleValueOutput(this IUnitOption option, Type inputType)
{
Ensure.That(nameof(inputType)).IsNotNull(inputType);
foreach (var valueOutputType in option.valueOutputTypes)
{
if (ConversionUtility.CanConvert(valueOutputType, inputType, false))
{
return(true);
}
}
return(false);
}
public static void UpdateWallStateArray(Packet _packet)
{
byte[] flatArray = _packet.ToArray();
byte[] targetArray = new byte[flatArray.Length - 4];
for (int i = 4; i < flatArray.Length; i++)
{
targetArray[i - 4] = flatArray[i];
}
bool[,,] _wallStateArray = new bool[GameManager.Width, GameManager.Depth, 4];
ConversionUtility.FromBytes <bool>(_wallStateArray, targetArray);
GameObject.Find("MazeManager").gameObject.GetComponent <MazeBuilder>().updateWallsUsingNewState(_wallStateArray);
}
private void CreateVertexBuffer()
{
var vertices = new VertexPositionNormalTexture[_sourceMesh.Positions.Count];
for (int i = 0; i < _sourceMesh.Positions.Count; i++)
{
vertices[i].Position = ConversionUtility.ToSharpDXVector3(_sourceMesh.Positions[i]);
vertices[i].Normal = ConversionUtility.ToSharpDXVector3(_sourceMesh.Normals[i]);
if (_sourceMesh.TextureCoordinates.Count - 1 >= i)
{
vertices[i].TextureCoordinate = new Vector2(_sourceMesh.TextureCoordinates[i].X, _sourceMesh.TextureCoordinates[i].Y);
}
}
_vertexBuffer = Buffer.Vertex.New(_device, vertices);
}
/// <summary>
/// Get value of the switch.
/// </summary>
public T GetValue <T>
(
[NotNull] string name,
[CanBeNull] T defaultValue
)
{
Code.NotNullNorEmpty(name, "name");
CommandLineSwitch found = GetSwitch(name);
T result = ReferenceEquals(found, null)
? defaultValue
: ConversionUtility.ConvertTo <T>(found.Value);
return(result);
}
private bool CanPredict(ValueInput input)
{
if (!input.hasValidConnection)
{
if (!TryGetDefaultValue(input, out var defaultValue))
{
return(false);
}
if (typeof(Component).IsAssignableFrom(input.type))
{
defaultValue = defaultValue?.ConvertTo(input.type);
}
if (!input.allowsNull && defaultValue == null)
{
return(false);
}
return(true);
}
var output = input.validConnectedPorts.Single();
if (!CanPredict(output))
{
return(false);
}
var connectedValue = GetValue(output);
if (!ConversionUtility.CanConvert(connectedValue, input.type, false))
{
return(false);
}
if (typeof(Component).IsAssignableFrom(input.type))
{
connectedValue = connectedValue?.ConvertTo(input.type);
}
if (!input.allowsNull && connectedValue == null)
{
return(false);
}
return(true);
}
public BlockJsonInfo[] Import(string name)
{
// Load image file and convert to Gamecraft blocks
Texture2D img = new Texture2D(64, 64);
// load file into texture
try
{
byte[] imgData = File.ReadAllBytes(name);
img.LoadImage(imgData);
}
catch (Exception e)
{
Logging.CommandLogError($"Failed to load picture data. Reason: {e.Message}");
Logging.MetaLog(e.Message + "\n" + e.StackTrace);
return(new BlockJsonInfo[0]);
}
//Logging.CommandLog($"Image size: {img.width}x{img.height}");
Player p = new Player(PlayerType.Local);
string pickedBlock = p.SelectedBlock == BlockIDs.Invalid ? BlockIDs.AluminiumCube.ToString() : p.SelectedBlock.ToString();
Quaternion imgRotation = Quaternion.Euler(Rotation);
BlockJsonInfo[] blocks = new BlockJsonInfo[img.width * img.height];
// convert the image to blocks
// optimisation occurs later
for (int x = 0; x < img.width; x++)
{
for (int y = 0; y < img.height; y++)
{
Color pixel = img.GetPixel(x, y);
float3 position = (imgRotation * (new float3((x * CommandRoot.BLOCK_SIZE), y * CommandRoot.BLOCK_SIZE, 0)));
BlockJsonInfo qPixel = new BlockJsonInfo
{
name = pixel.a > 0.75 ? pickedBlock : BlockIDs.GlassCube.ToString(),
color = new float[] { pixel.r, pixel.g, pixel.b },
rotation = ConversionUtility.Float3ToFloatArray(Rotation),
position = ConversionUtility.Float3ToFloatArray(position),
scale = new float[] { 1, 1, Thiccness },
};
if (pixel.a < 0.5f)
{
qPixel.name = BlockIDs.Invalid.ToString();
}
blocks[(x * img.height) + y] = qPixel;
}
}
return(blocks);
}
private ResolvedJoinInfo CreateResolvedJoinInfo(
SqlEntityExpression originatingEntity,
string leftColumnName,
Type leftColumnType,
bool leftColumnIsPrimaryKey,
IResolvedTableInfo joinedTableInfo,
string rightColumnName,
Type rightColumnType,
bool rightColumnIsPrimaryKey)
{
var leftColumn = originatingEntity.GetColumn(leftColumnType, leftColumnName, leftColumnIsPrimaryKey);
var rightColumn = CreateColumn(rightColumnType, joinedTableInfo.TableAlias, rightColumnName, rightColumnIsPrimaryKey);
return(new ResolvedJoinInfo(
joinedTableInfo, ConversionUtility.MakeBinaryWithOperandConversion(ExpressionType.Equal, leftColumn, rightColumn, false, null)));
}
public override void Visit(TernaryExpression ternary)
{
// Evaluates the left expression and saves the value
ternary.LeftExpression.Accept(this);
var left = ConversionUtility.Convert <bool>(Result);
if (left)
{
ternary.MiddleExpression.Accept(this);
}
else
{
ternary.RightExpression.Accept(this);
}
}
/// <summary>
/// Deserialize an Azure DevOps Pipeline with a complex trigger and simple variable list
/// </summary>
/// <param name="yaml">yaml to convert</param>
/// <returns>Azure DevOps Pipeline with complex trigger and simple variables</returns>
public static AzurePipelinesRoot <AzurePipelines.Trigger, Dictionary <string, string> > DeserializeComplexTriggerAndSimpleVariables(string yaml)
{
AzurePipelinesRoot <AzurePipelines.Trigger, Dictionary <string, string> > azurePipeline = null;
try
{
yaml = CleanYamlBeforeDeserialization(yaml);
azurePipeline = GenericObjectSerialization.DeserializeYaml <AzurePipelinesRoot <AzurePipelines.Trigger, Dictionary <string, string> > >(yaml);
}
catch (Exception ex)
{
ConversionUtility.WriteLine($"{nameof(DeserializeComplexTriggerAndSimpleVariables)} swallowed an exception: " + ex.Message, true);
//Do nothing
}
return(azurePipeline);
}
public static T GetValueSensitive <T>
(
[NotNull] this MenuFile menu,
[NotNull] string code,
T defaultValue
)
{
Sure.NotNull(menu, nameof(menu));
Sure.NotNull(code, nameof(code));
MenuEntry found = menu.FindEntrySensitive(code);
return(found == null
? defaultValue
: ConversionUtility.ConvertTo <T>(found.Comment));
}
public void AnonymousArray_SameProperties_CleverConverts()
{
var arr = new[]
{
new { Name = "Fred", Age = 20 },
new { Name = "Bill", Age = 43 },
new { Name = "Ben", Age = 65 }
};
var model = ConversionUtility.CleverConvertValue <TestModel[]>(arr);
Assert.Equal(arr[0].Name, model[0].Name);
Assert.Equal(arr[1].Age, model[1].Age);
Assert.Equal(arr[2].Name, model[2].Name);
Assert.Equal(arr[2].Age, model[2].Age);
}
/// <summary>
/// Get boolean value from application configuration.
/// </summary>
public static bool GetBoolean
(
[NotNull] string key,
bool defaultValue = false
)
{
bool result = defaultValue;
string setting = CM.AppSettings[key];
if (!string.IsNullOrEmpty(setting))
{
result = ConversionUtility.ToBoolean(setting);
}
return(result);
}
public Expression GetFilterExpression(ParameterExpression itemPram, FilterComparisonOperator comparisonOperator, string valueString)
{
var getterMemberExpr = _reader.GetSelectExpression(itemPram);
if (getterMemberExpr == null)
{
throw new InvalidCastException("Getter expression returned from IFieldReader is not of type MemberExpression.");
}
object valueObj = ConversionUtility.ConvertString(valueString, _reader.FieldType);
ConstantExpression variableExpression = Expression.Constant(valueObj, _reader.FieldType); // TODO variable not constant?
var operatorMethod = GetOperatorExpressionMethod(comparisonOperator);
Expression predicateExpression = operatorMethod.Invoke(getterMemberExpr, variableExpression);
return(predicateExpression);
}
public TItem GetAlreadyLoadedItem(string identifier)
{
var parameters = _getterMethod.GetParameters();
Debug.Assert(parameters.Length == 1, "Should be exactly 1 parameter by the time we get here.");
Type paramType = parameters[0].ParameterType;
object arg = ConversionUtility.ConvertString(identifier, paramType);
object methodValue = _getterMethod.Invoke(_instance, new object[] { arg });
if (methodValue is TItem)
{
return((TItem)methodValue);
}
throw new IdentifierMethodNullException();
}
public string ToString(FieldInfo fieldInfo, bool showRaw)
{
if (showRaw)
{
return("" + m_Value);
}
else
{
if (fieldInfo.delta)
{
return("" + ((int)m_Value * NetworkConfig.decoderPrecisionScales[fieldInfo.precision]));
}
else
{
return("" + ConversionUtility.UInt32ToFloat(m_Value));
}
}
}
public static T GetParameter <T>
(
[NotNull] this Parameter[] parameters,
[NotNull] string name,
[CanBeNull] T defaultValue
)
{
Sure.NotNull(parameters, nameof(parameters));
Sure.NotNullNorEmpty(name, nameof(name));
Parameter found = parameters
.FirstOrDefault(p => p.Name.SameString(name));
T result = ReferenceEquals(found, null)
? defaultValue
: ConversionUtility.ConvertTo <T>(found.Value);
return(result);
}
/// <summary>
/// Get boolean value from application configuration.
/// </summary>
public static bool GetBoolean
(
[NotNull] string key,
bool defaultValue
)
{
#if DROID || ANDROID || UAP
return(defaultValue);
#else
bool result = defaultValue;
string s = CM.AppSettings[key];
if (!string.IsNullOrEmpty(s))
{
result = ConversionUtility.ToBoolean(s);
}
return(result);
#endif
}
public T GetValue <T>
(
[NotNull] string key,
[CanBeNull] T defaultValue
)
{
Code.NotNullNorEmpty(key, "key");
string value = GetValue(key, null);
if (string.IsNullOrEmpty(value))
{
return(defaultValue);
}
T result = ConversionUtility.ConvertTo <T>(value);
return(result);
}
public void GenerateSpacesTest()
{
//Arrange
int number0 = 0;
int number1 = 1;
int number4 = 4;
int number9 = 9;
//Act
string results0 = ConversionUtility.GenerateSpaces(number0);
string results1 = ConversionUtility.GenerateSpaces(number1);
string results4 = ConversionUtility.GenerateSpaces(number4);
string results9 = ConversionUtility.GenerateSpaces(number9);
//Assert
Assert.AreEqual("", results0);
Assert.AreEqual(" ", results1);
Assert.AreEqual(" ", results4);
Assert.AreEqual(" ", results9);
}
