public void ExtractChanges(object instance, ChangeReceiverDelegate changeReceiver)
{
// Contract
if (instance == null)
{
throw new ArgumentNullException("instance", "Can not extract changes on a null reference");
}
for (int index = 0; index < FieldNames.Length; index++)
{
var familyName = FamilyNames[index];
var fieldName = FieldNames[index];
var memberType = MemberTypes[MemberNameLookup[fieldName]];
if (false && IsBigBoxed[fieldName])
{
}
else
{
var value = Getters[fieldName](instance);
var serializer = GetSerializerForType(memberType);
var valueBytes = serializer.SerializeField(memberType, value, TableEncoding);
changeReceiver(familyName, fieldName, valueBytes);
}
}
}
internal void Export(Exporter exporter, object value)
{
exporter.Blob.BeginSequence(Coherent.UI.Mobile.Binding.ValueType.Object, Getters.Length + 1);
exporter.Export("__Type");
exporter.Export(RealTypeName);
for (var i = 0; i < Getters.Length; ++i)
{
exporter.Export(Names[i]);
Getters[i](value, exporter);
}
exporter.Blob.EndSequence();
}
public void CorrectlyPassData()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var teamName = "TeamName";
var teamMock = new Mock <ITeam>();
wimTeamMock.Setup(x => x.TeamsList.ContainsKey(teamName)).Returns(true);
var boardName = "BoardName";
wimTeamMock.Setup(x => x.TeamsList[teamName].BoardList.ContainsKey(boardName)).Returns(true);
var boardMock = new Mock <IBoard>();
boardMock.Setup(x => x.BoardName).Returns(boardName);
wimTeamMock.Setup(x => x[teamName]).Returns(teamMock.Object);
teamMock.Setup(x => x.BoardList[boardName]).Returns(boardMock.Object);
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act
var getBoard = sut.GetBoard(teamName, boardName);
//Assert
Assert.AreEqual(boardMock.Object, getBoard);
}
internal List <Getters> GetGetters(Type type)
{
if (_getterscache.ContainsKey(type))
{
return(_getterscache[type]);
}
else
{
PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
List <Getters> getters = new List <Getters>();
foreach (PropertyInfo p in props)
{
GenericGetter g = CreateGetMethod(p);
if (g != null)
{
Getters gg = new Getters();
gg.Name = p.Name;
gg.Getter = g;
getters.Add(gg);
}
}
_getterscache.Add(type, getters);
return(getters);
}
}
private static Result createReshoringLayoutSheets(UIDocument uiDoc)
{
Document _doc = uiDoc.Document;
string _titleblockName = "E1 30 x 42 Horizontal: E1 30x42 Horizontal";
XYZ _columnScheduleBottomLeft = new XYZ(2.3354130772204, 2.39482128194158, 0);
XYZ _viewCenter = new XYZ(1.45453036348288, 1.18116967618813, 0.871414246948733);
XYZ _levelScheduleBottomLeft = new XYZ(0.156336990263879, 2.37688649933288, 0);
var _levels = Getters.GetLevels(_doc);
Level _levelAbove = null;
Level _topLevel = _levels.FirstOrDefault();
Level _bottomLevel = _levels.LastOrDefault();
List <Tuple <ViewSheet, View> > _sheetsWithViews = new List <Tuple <ViewSheet, View> >();
foreach (Level _level in _levels)
{
if (_levelAbove == null)
{
_levelAbove = _level;
}
BoundedViewCreator _boundedViewCreator = new BoundedViewCreator(_level, null, null);
SheetCreator _sheetCreator = new SheetCreator(_doc);
string _viewName = _boundedViewCreator.GetViewName(string.Empty, "FP");
ViewSheet _viewSheet = _sheetCreator.CreateSheet(_titleblockName, _viewName, _viewName);
ViewPlan _viewPlan = _boundedViewCreator.CreateViewPlan(80);
_sheetsWithViews.Add(new Tuple <ViewSheet, View>(_viewSheet, _viewPlan));
ViewSchedule _columnSchedule = ScheduleCreator.CreateLayoutColumnSchedule(_doc, _level.Name, " Reshores");
ScheduleSheetInstance _columnScheduleSheetInstance = ScheduleSheetInstance.Create(_doc, _viewSheet.Id, _columnSchedule.Id, _columnScheduleBottomLeft);
ViewSchedule _levelSchedule = ScheduleCreator.CreateLayoutLoadSchedule(_doc, _level.Name, " Loads");
ScheduleSheetInstance _levelScheduleSheetInstance = ScheduleSheetInstance.Create(_doc, _viewSheet.Id, _levelSchedule.Id, _levelScheduleBottomLeft);
_levelAbove = _level;
}
_doc.Regenerate();
FamilySymbol _tagSymbol = new FilteredElementCollector(_doc)
.OfCategory(BuiltInCategory.OST_MultiCategoryTags)
.OfClass(typeof(FamilySymbol)).OfType <FamilySymbol>()
.FirstOrDefault(p => p.FamilyName.Contains("Mark"));
foreach (var _sheetWithView in _sheetsWithViews)
{
DimensionCreator.CreateDimensions(_sheetWithView.Item2);
TagCreator.CreateTags(_sheetWithView.Item2, _tagSymbol);
Viewport.Create(_doc, _sheetWithView.Item1.Id, _sheetWithView.Item2.Id, _viewCenter);
}
return(Result.Succeeded);
}
public override void InitStats()
{
base.InitStats();
Getters.Add("Killstreak", delegate() { return(Killstreak); });
Setters.Add("Killstreak", delegate(object val) { Killstreak = (int)val; });
}
private void SetDropForLevel(Tier tier, Difficulty diff)
{
Dictionary <IBonus, int> set = new Dictionary <IBonus, int>();
foreach (var pair in Getters.GetDrop(tier))
{
set.Add(pair.Key, pair.Value * (int)diff);
}
level.SetDroppables(set);
}
internal object GetValue(T value, string propertyName)
{
var getter = Getters.GetOrAdd(propertyName, name =>
{
var propertyInfo = GetType().GetProperty(name);
return(ResolveGetter(propertyInfo));
});
return(getter.Invoke(value));
}
private void CachePropertyGetter(string propertyName)
{
if (Getters.ContainsKey(propertyName))
{
return;
}
var propInfo = GetType().GetProperty(propertyName);
Getters.Add(propertyName, obj => propInfo.GetValue(obj));
}
public void Throw_ArgumentNullException_When_PersonDontExist()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wIMTeamMock = new Mock <IWIMTeams>();
var sut = new Getters(personListMock.Object, wIMTeamMock.Object);
//Act&&Assert
var ex = Assert.ThrowsException <ArgumentNullException>(() => sut.GetPerson("Some Member"));
Assert.AreEqual(string.Format(CommandsConsts.NoPersonFound, "Some Member"), ex.ParamName);
}
public StringGetter[] GetGettersCollection()
{
StringGetter[] getters = new StringGetter[BuiltInGetters.Length + Getters.Count];
int i = 0;
foreach (StringGetter get in Getters.Concat(BuiltInGetters))
{
getters[i] = get;
i++;
}
return(getters);
}
public override void InitStats()
{
base.InitStats();
Getters.Add("Deaths", delegate() { return(Deaths); });
Getters.Add("Frags", delegate() { return(Frags); });
Getters.Add("Score", delegate() { return(Score); });
Setters.Add("Deaths", delegate(object val) { Deaths = (int)val; });
Setters.Add("Frags", delegate(object val) { Frags = (int)val; });
Setters.Add("Score", delegate(object val) { Score = (int)val; });
}
private object BindParameter(DisplayContext displayContext, ParameterInfo parameter, TextWriter output)
{
if (parameter.Name == "Shape")
{
return(displayContext.Value);
}
if (parameter.Name == "Display")
{
return(displayContext.Display);
}
if (parameter.Name == "Output" && parameter.ParameterType == typeof(TextWriter))
{
return(output);
}
if (parameter.Name == "Output" && parameter.ParameterType == typeof(Action <object>))
{
return(new Action <object>(output.Write));
}
if (parameter.Name == "Html")
{
return(new HtmlHelper(
displayContext.ViewContext,
displayContext.ViewDataContainer,
_routeCollection));
}
if (parameter.Name == "Url" && parameter.ParameterType.IsAssignableFrom(typeof(UrlHelper)))
{
return(new UrlHelper(displayContext.ViewContext.RequestContext, _routeCollection));
}
var getter = Getters.GetOrAdd(parameter.Name, n =>
CallSite <Func <CallSite, object, dynamic> > .Create(
Microsoft.CSharp.RuntimeBinder.Binder.GetMember(
CSharpBinderFlags.None, n, null, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) })));
var result = getter.Target(getter, displayContext.Value);
if (result == null)
{
return(null);
}
var converter = Converters.GetOrAdd(parameter.ParameterType, CompileConverter);
var argument = converter.Invoke(result);
return(argument);
}
public void Throw_ArgumentException_When_ТеамDontExist()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var teamName = "TeamName";
wimTeamMock.Setup(x => x.TeamsList.ContainsKey(teamName)).Returns(false);
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act&&Assert
var ex = Assert.ThrowsException <ArgumentException>(() => sut.GetTeam(teamName));
Assert.AreEqual(string.Format(CommandsConsts.NoTeamFound, teamName), ex.Message);
}
public void Throw_ArgumentException_When_WorkItemDontExistInTheBoard()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var boardMock = new Mock <IBoard>();
boardMock.Setup(x => x.BoardWorkItems).Returns(new Dictionary <string, IWorkItem>());
var workItem = "WorkItem";
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act&&Assert
var ex = Assert.ThrowsException <ArgumentException>(() => sut.GetWorkItem(boardMock.Object, workItem));
Assert.AreEqual(string.Format(CommandsConsts.NoWorkItemFound, workItem), ex.Message);
}
static (PropertyModification, PropertyModification) GetModificationsOrNull(Type type, string property, object previousValue, object newValue)
{
var getter = Getters
.GetOrAdd(type, _ => new ConcurrentDictionary <string, Func <object, object, (PropertyModification, PropertyModification)> >())
.GetOrAdd(property, _ => CreateModificationGetter(type, property));
try
{
return(getter(previousValue, newValue));
}
catch (Exception exception)
{
throw new ArgumentException($"Could not generate property modifications for the '{property}' property of {type}, value changed from {previousValue} to {newValue}", exception);
}
}
public void Throw_ArgumentNullException_When_TeamDontExist()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wIMTeamMock = new Mock <IWIMTeams>();
wIMTeamMock.Setup(w => w.TeamsList).Returns(new Mock <IDictionary <string, ITeam> >().Object);
var teamMock = new Mock <ITeam>();
teamMock.Setup(x => x.TeamName).Returns("TeamName");
var sut = new Getters(personListMock.Object, wIMTeamMock.Object);
//Act&&Assert
var ex = Assert.ThrowsException <ArgumentException>(() => sut.GetMember(teamMock.Object, "Pesho"));
Assert.AreEqual(string.Format(CommandsConsts.NoTeamFound, teamMock.Object.TeamName), ex.Message);
}
private Action ParseAction(string text)
{
var action = text.Split('/');
switch (action[0])
{
case "ChangeArmor": return(() => EventResult_ChangeArmor(int.Parse(action[1])));
case "ReceiveGold": return(() => EventResult_ReceiveGold(int.Parse(action[1])));
case "HealthChange": return(() => EventResult_HealthChange(int.Parse(action[1])));
case "ReceiveLoot": return(() => EventResult_ReceiveLoot(Getters.ParseLoot(action.Skip(1))));
}
return(null);
}
public SheetCreator(Document doc)
{
var _titleblocks = Getters.GetTitleblockSymbols(doc);
_titleblockMaps = new Dictionary <string, FamilySymbol>();
foreach (var _titleblock in _titleblocks)
{
string _key = _titleblock.FamilyName + ": " + _titleblock.Name;
if (_titleblockMaps.ContainsKey(_key))
{
continue;
}
_titleblockMaps.Add(_key, _titleblock);
}
}
public void CorrectlyPassData()
{
//Arrange
var wIMTeamMock = new Mock <IWIMTeams>();
var personListMock = new Mock <IPersonsCollection>();
personListMock.Setup(x => x.Contains("Pesho")).Returns(true);
personListMock.SetupGet(p => p["Pesho"]).Returns(new Mock <IPerson>().Object);
var sut = new Getters(personListMock.Object, wIMTeamMock.Object);
//Act
var getPerson = sut.GetPerson("Pesho");
//Assert
personListMock.Verify(x => x.Contains("Pesho"), Times.Once);
personListMock.Verify(p => p["Pesho"], Times.Once);
}
public void Throw_ArgumentException_When_BoardDontExist()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var teamName = "TeamName";
wimTeamMock.Setup(x => x.TeamsList.ContainsKey(teamName)).Returns(true);
var boardName = "BoardName";
wimTeamMock.Setup(x => x.TeamsList[teamName].BoardList).Returns(new Dictionary <string, IBoard>());
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act&&Assert
var ex = Assert.ThrowsException <ArgumentException>(() => sut.GetBoard(teamName, boardName));
Assert.AreEqual(string.Format(CommandsConsts.NoBoardFound, boardName), ex.Message);
}
public void CorrectlyPassData()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var boardMock = new Mock <IBoard>();
var workItem = "WorkItem";
var workItemMock = new Mock <IWorkItem>();
boardMock.Setup(x => x.BoardWorkItems[workItem]).Returns(workItemMock.Object);
boardMock.Setup(x => x.BoardWorkItems.ContainsKey(workItem)).Returns(true);
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act
var GetWorkItem = sut.GetWorkItem(boardMock.Object, workItem);
//Assert
Assert.AreEqual(workItemMock.Object, GetWorkItem);
}
public IEnumerable <string> Format(IEnumerable <T> input)
{
Func <object, string> toStringOrEmpty = _ => _?.ToString() ?? string.Empty;
var cached = input.ToList();
int[] widths = cached.Aggregate(
Names.Select(_ => _.Length).ToArray(), // seed
(accu, current) => Enumerable.Zip(
accu,
Getters.Select(_ => toStringOrEmpty(_(current)).Length),
max).ToArray());
string template = string.Join("", Enumerable.Range(0, widths.Length).Select(i => string.Format("{{{0},{2}{1}}}", i, (int)(widths[i] * 1.2), Alignments[i])));
yield return(string.Format(template, Names));
foreach (var obj in cached)
{
yield return(string.Format(template, Getters.Select(getCol => getCol(obj)).ToArray()));
}
}
public void Throw_ArgumentException_When_WorkItemIsNotAssignable()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var workItemMock = new Mock <IWorkItem>();
workItemMock.Setup(x => x.Title).Returns("WorkItem");
var boardMock = new Mock <IBoard>();
boardMock.Setup(x => x.BoardWorkItems).Returns(
new Dictionary <string, IWorkItem> {
{ "WorkItem", workItemMock.Object }
});
boardMock.Setup(x => x.BoardWorkItems["WorkItem"]).Returns(workItemMock.Object);
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act&&Assert
var ex = Assert.ThrowsException <ArgumentException>(() => sut.GetAssignableWorkItem(boardMock.Object, workItemMock.Object.Title));
Assert.AreEqual(string.Format($"{boardMock.Object.BoardWorkItems["WorkItem"].GetType().Name} is not assignable work item!"), ex.Message);
}
public void CorrectlyPassData()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wIMTeamMock = new Mock <IWIMTeams>();
var teamMock = new Mock <ITeam>();
wIMTeamMock.Setup(x => x.TeamsList);
var teamName = "TeamName";
teamMock.Setup(x => x.TeamName).Returns(teamName);
wIMTeamMock.Setup(x => x[teamName]).Returns(teamMock.Object);
wIMTeamMock.Setup(x => x.TeamsList.ContainsKey(teamName)).Returns(true);
var sut = new Getters(personListMock.Object, wIMTeamMock.Object);
//Act
var getTeam = sut.GetTeam(teamName);
//Assert
Assert.AreEqual(teamMock.Object, getTeam);
}
public void Init()
{
var requestAttribute = ParameterType.CustomAttribute <HttpRequestAttribute>(true);
if (null != requestAttribute)
{
UrlPattern = requestAttribute.Api;
Method = requestAttribute.Method;
Host = requestAttribute.Host;
ParameterType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToList().ForEach(propertyInfo =>
{
var propertyName = propertyInfo.Name;
var getter = ResolveGetter(propertyInfo);
Getters.AddOrUpdate(propertyName, getter, (k, v) => getter);
var attribute = propertyInfo.CustomAttribute <HttpComponentAttribute>(true);
if (null == attribute)
{
return;
}
var component = new HttpComponentInfo(propertyName, attribute, NamingRule);
Components.AddOrUpdate(propertyName, component, (p, a) => component);
});
}
}
public void CorrectlyPassData()
{
//Arrange
var personListMock = new Mock <IPersonsCollection>();
var wimTeamMock = new Mock <IWIMTeams>();
var workItemMock = new Mock <IAssignableWorkItem>();
workItemMock.Setup(x => x.Title).Returns("WorkItem");
var boardMock = new Mock <IBoard>();
boardMock.Setup(x => x.BoardWorkItems).Returns(
new Dictionary <string, IWorkItem> {
{ "WorkItem", workItemMock.Object }
});
boardMock.Setup(x => x.BoardWorkItems["WorkItem"]).Returns(workItemMock.Object);
var sut = new Getters(personListMock.Object, wimTeamMock.Object);
//Act
var GetWorkItem = sut.GetAssignableWorkItem(boardMock.Object, "WorkItem");
//Assert
Assert.AreEqual(workItemMock.Object, GetWorkItem);
}
public void UnregisterProperty(string name)
{
Getters.Remove(name);
Setters.Remove(name);
}
public static object Eval(this object target, string name)
{
return(Getters.Select(getter => getter(target, name)).Where(value => value != NextGetter).First());
}
private object GetPropertyValue(string propertyName)
{
return(Getters[propertyName](this));
}
