public void TestSorting(bool isAscending, SortingMode sortingColumn, bool expected)
{
var dateTime = DateTime.UtcNow;
var firstFileViewModel = _autoMocker.CreateInstance <FileViewModel>();
firstFileViewModel.Name = "Program";
firstFileViewModel.Extension = "cs";
firstFileViewModel.Size = 1024;
firstFileViewModel.LastModifiedDateTime = dateTime;
var secondFileViewModel = _autoMocker.CreateInstance <FileViewModel>();
secondFileViewModel.Name = "module";
secondFileViewModel.Extension = "js";
secondFileViewModel.Size = 2048;
secondFileViewModel.LastModifiedDateTime = dateTime.AddDays(1);
var comparer = new FileViewModelsComparer(isAscending, sortingColumn);
var result = comparer.Compare(firstFileViewModel, secondFileViewModel);
Assert.Equal(expected, result > 0);
result = comparer.Compare(secondFileViewModel, firstFileViewModel);
Assert.Equal(expected, result < 0);
}
public async Task<List<Ticket>> GetPrice(
string token,
string origin,
string destination,
DateTime departDate,
DateTime returnDate,
PeriodType period = PeriodType.Year,
bool isOneWay = false,
int page = 1,
int limit = 30,
bool isShowToAffiliates = true,
SortingMode sorting = SortingMode.Price,
TripClassMode tripClass = TripClassMode.Econom)
{
var settings = new QuerySettings(origin, destination)
{
BeginningOfPeriod = departDate,
Period = period,
IsOneWay = isOneWay,
Page = page,
Limit = limit,
IsShowToAffiliates = isShowToAffiliates,
Sorting = sorting,
TripClass = tripClass,
};
var interval = returnDate - departDate;
settings.TripDuration = period == PeriodType.Day ? interval.Days : interval.Days / 7;
return await GetPrice(token, settings);
}
public async Task <List <Ticket> > GetPrice(
string token,
string origin,
string destination,
DateTime departDate,
DateTime returnDate,
PeriodType period = PeriodType.Year,
bool isOneWay = false,
int page = 1,
int limit = 30,
bool isShowToAffiliates = true,
SortingMode sorting = SortingMode.Price,
TripClassMode tripClass = TripClassMode.Econom)
{
var settings = new QuerySettings(origin, destination)
{
BeginningOfPeriod = departDate,
Period = period,
IsOneWay = isOneWay,
Page = page,
Limit = limit,
IsShowToAffiliates = isShowToAffiliates,
Sorting = sorting,
TripClass = tripClass,
};
var interval = returnDate - departDate;
settings.TripDuration = period == PeriodType.Day ? interval.Days : interval.Days / 7;
return(await GetPrice(token, settings));
}
public void SortMembers(SortingMode sortingMode)
{
switch (sortingMode)
{
case SortingMode.ByName:
OnBeginUndoableOperation();
FieldList.Sort(MemberComparisonByName);
OperationList.Sort(MemberComparisonByName);
Changed();
break;
case SortingMode.ByAccess:
OnBeginUndoableOperation();
FieldList.Sort(MemberComparisonByAccess);
OperationList.Sort(MemberComparisonByAccess);
Changed();
break;
case SortingMode.ByKind:
OnBeginUndoableOperation();
FieldList.Sort(MemberComparisonByKind);
OperationList.Sort(MemberComparisonByKind);
Changed();
break;
}
}
public void Sort(ref T[] array, SortingMode mode, IComparer <T> obj, params object[] optional)
{
if (array is null)
{
throw new ArgumentNullException(nameof(array));
}
if (obj is null)
{
throw new ArgumentNullException(nameof(obj));
}
int count = array.Length;
for (int i = count / 2 - 1; i >= 0; i--)
{
Heap(ref array, count, i, obj, mode);
}
for (int i = count - 1; i >= 0; i--)
{
Swap(ref array[0], ref array[i]);
Heap(ref array, i, 0, obj, mode);
}
}
public UIInstruction(UIObject ui, Anchor a, SortingMode s, Point o)
{
uiObject = ui;
anchor = a;
sortingMode = s;
offset = o;
}
/// <private/>
public void DBClear()
{
bonesRoot = null;
if (_armature != null)
{
_armature = null;
if (_disposeProxy)
{
UnityFactoryHelper.DestroyUnityObject(gameObject);
}
}
_disposeProxy = true;
_armature = null;
unityData = null;
armatureName = null;
animationName = null;
isUGUI = false;
addNormal = false;
unityBones = null;
boneHierarchy = false;
_colorTransform.Identity();
_sortingMode = SortingMode.SortByZ;
_sortingLayerName = "Default";
_sortingOrder = 0;
_playTimes = 0;
_timeScale = 1.0f;
_zSpace = 0.0f;
_flipX = false;
_flipY = false;
_sortedSlots = null;
_hasSortingGroup = false;
}
// METHODS
// Analyze the character frequencies of a text file and save frequency file.
// Read file on the fly.
public void Analyze(string inputFile, string outputFile, SortingMode sort)
{
StreamReader input;
StreamWriter output;
try
{
input = new StreamReader(new FileStream(inputFile, FileMode.Open));
output = new StreamWriter(new FileStream(outputFile, FileMode.Create));
char c;
while (!input.EndOfStream)
{
c = (char)input.Read(); // [wip] why does this return an int32?
Counter.Add(c);
}
List <char> letters = Counter.Characters(sort);
foreach (char letter in letters)
{
output.WriteLine("{0}\t{1}", letter, Counter.GetCount(letter));
}
input.Dispose();
output.Dispose();
}
catch (Exception ex)
{
Console.WriteLine("Error Occured");
Console.WriteLine(ex.Message);
}
}
public OrderByMember Add(FieldIdentifier field, SortingMode mode = SortingMode.Ascending)
{
var member = new OrderByMember(field, mode);
this.Members.Add(member);
return(member);
}
/// <summary>
/// Applies sorting.
/// </summary>
private void ApplySorting()
{
// Sort by order.
if (SortingMode.SortByOrder())
{
MeshRenderer.sortingOrder = SortingOrder + ((SortingMode == CubismSortingMode.BackToFrontOrder)
? (RenderOrder + LocalSortingOrder)
: -(RenderOrder + LocalSortingOrder));
transform.localPosition = Vector3.zero;
return;
}
// Sort by depth.
var offset = (SortingMode == CubismSortingMode.BackToFrontZ)
? -DepthOffset
: DepthOffset;
MeshRenderer.sortingOrder = SortingOrder + LocalSortingOrder;
transform.localPosition = new Vector3(0f, 0f, RenderOrder * offset);
}
private void Start()
{
inventoryManagement = this;
currentAll.onClick.AddListener(delegate { currentCategory = ItemCategory.all; showCurrent(); });
currentUpgrade.onClick.AddListener(delegate { currentCategory = ItemCategory.upgrade; showCurrent(); });
currentLuxury.onClick.AddListener(delegate { currentCategory = ItemCategory.luxury; showCurrent(); });
currentIndustry.onClick.AddListener(delegate { currentCategory = ItemCategory.industry; showCurrent(); });
currentCommon.onClick.AddListener(delegate { currentCategory = ItemCategory.common; showCurrent(); });
currentFood.onClick.AddListener(delegate { currentCategory = ItemCategory.food; showCurrent(); });
currentSupplies.onClick.AddListener(delegate { currentCategory = ItemCategory.supplies; showCurrent(); });
currentAlpha.onClick.AddListener(delegate { currentSortingMode = SortingMode.alphabet; showCurrent(); });
currentWeightSingle.onClick.AddListener(delegate { currentSortingMode = SortingMode.weightSingle; showCurrent(); });
currentWeightTotal.onClick.AddListener(delegate { currentSortingMode = SortingMode.weightTotal; showCurrent(); });
currentValueSingle.onClick.AddListener(delegate { currentSortingMode = SortingMode.valueSingle; showCurrent(); });
currentValueTotal.onClick.AddListener(delegate { currentSortingMode = SortingMode.valueTotal; showCurrent(); });
currentAmountTotal.onClick.AddListener(delegate { currentSortingMode = SortingMode.amount; showCurrent(); });
selectingAll.onClick.AddListener(delegate { selectingCategory = ItemCategory.all; showSelecting(); });
selectingUpgrade.onClick.AddListener(delegate { selectingCategory = ItemCategory.upgrade; showSelecting(); });
selectingLuxury.onClick.AddListener(delegate { selectingCategory = ItemCategory.luxury; showSelecting(); });
selectingIndustry.onClick.AddListener(delegate { selectingCategory = ItemCategory.industry; showSelecting(); });
selectingCommon.onClick.AddListener(delegate { selectingCategory = ItemCategory.common; showSelecting(); });
selectingFood.onClick.AddListener(delegate { selectingCategory = ItemCategory.food; showSelecting(); });
selectingSupplies.onClick.AddListener(delegate { selectingCategory = ItemCategory.supplies; showSelecting(); });
selectingAlpha.onClick.AddListener(delegate { selectingSortingMode = SortingMode.alphabet; showSelecting(); });
selectingWeightSingle.onClick.AddListener(delegate { selectingSortingMode = SortingMode.weightSingle; showSelecting(); });
selectingWeightTotal.onClick.AddListener(delegate { selectingSortingMode = SortingMode.weightTotal; showSelecting(); });
selectingValueSingle.onClick.AddListener(delegate { selectingSortingMode = SortingMode.valueSingle; showSelecting(); });
selectingValueTotal.onClick.AddListener(delegate { selectingSortingMode = SortingMode.valueTotal; showSelecting(); });
selectingAmountTotal.onClick.AddListener(delegate { selectingSortingMode = SortingMode.amount; showSelecting(); });
}
protected override int Compare(DirectoryViewModel x, DirectoryViewModel y, SortingMode sortingColumn,
bool isAscending)
{
if (x.IsParentDirectory)
{
return(-1);
}
if (y.IsParentDirectory)
{
return(1);
}
var sortingByNameColumns = new[] { SortingMode.Extension, SortingMode.Size, SortingMode.Name };
var result = sortingColumn switch
{
_ when sortingByNameColumns.Contains(sortingColumn) =>
string.Compare(PreprocessFileName(x.Name), PreprocessFileName(y.Name), StringComparison.Ordinal),
SortingMode.Date => x.LastModifiedDateTime.CompareTo(y.LastModifiedDateTime),
_ => throw new ArgumentOutOfRangeException(nameof(sortingColumn), sortingColumn, null)
};
return(isAscending ? result : -result);
}
}
/// <summary>
/// 初始化 <see cref="Sorting"/> 类的新实例。
/// </summary>
/// <param name="member">排序成员。</param>
/// <param name="mode">排序方式。</param>
public Sorting(T member, SortingMode mode)
{
var entry = EnumUtility.GetEnumEntry(member as Enum);
this.Name = !string.IsNullOrEmpty(entry.Alias) ? entry.Alias : entry.Name;
this.Member = member;
this.Mode = mode;
}
public Sorting(SortingMode mode, params string[] members)
{
if(members == null || members.Length == 0)
throw new ArgumentNullException("members");
this.Mode = mode;
this.Members = members;
}
/// <summary>
/// Construct and draw a new UIObject
/// </summary>
/// <param name="name">Name of UIObject</param>
/// <param name="offset">Offset from calculated anchor position</param>
/// <param name="anchor">Where is this anchored to on the screen</param>
/// <param name="sortingMode">How to organize with repsect to other UIObjects</param>
/// <param name="activeState">GameState when this should be drawn</param>
public UIObject(string name, Anchor anchor, SortingMode sortingMode, GameState activeState, Point offset) :
base(name, Rectangle.Empty)
{
ActiveState = activeState;
this.anchor = anchor;
this.sortingMode = sortingMode;
AlwaysDraw = true;
}
public static BackingBox Build(IType InteractionType, Box B, SortingMode SortMode = SortingMode.Box)
{
BackingBox b = boxPool.Rent();
b.InteractionType = InteractionType;
b.B = B;
b.SortMode = SortMode;
return(b);
}
/// <summary>
/// 初始化 <see cref="Sorting"/> 类的新实例。
/// </summary>
/// <param name="name">成员名称。</param>
/// <param name="mode">排序方式。</param>
public Sorting(string name, SortingMode mode)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
this.Name = name;
this.Mode = mode;
}
public Sorting(SortingMode mode, params string[] members)
{
if (members == null || members.Length == 0)
{
throw new ArgumentNullException("members");
}
this.Mode = mode;
this.Members = members;
}
public Sorting(string name, SortingMode mode = SortingMode.Ascending)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
_name = name;
_mode = mode;
}
public FileSystemNodesSortingViewModel(
SortingMode sortingColumn,
bool isSortingByAscendingEnabled)
{
SortingColumn = sortingColumn;
IsSortingByAscendingEnabled = isSortingByAscendingEnabled;
this.WhenAnyValue(vm => vm.SortingColumn, vm => vm.IsSortingByAscendingEnabled)
.Subscribe(_ => FireSortingSettingsChangedEvent());
}
public UIImage(string name, Texture2D texture, Point size, Anchor anchor, SortingMode sortingMode, GameState activeState, Point offset, Color color) : base(name, anchor, sortingMode, activeState, offset)
{
//Store info
Texture = texture;
Location = new Rectangle(Point.Zero, size);
DrawColor = color;
//Anchor it
UIManager.AddAnchoredObject(this, anchor, sortingMode, offset);
}
private void _UpdateSortingGroup()
{
//发现骨架有SortingGroup，那么子骨架也都加上，反之删除
_sortingGroup = GetComponent <UnityEngine.Rendering.SortingGroup>();
if (_sortingGroup != null)
{
_sortingMode = SortingMode.SortByOrder;
_sortingLayerName = _sortingGroup.sortingLayerName;
_sortingOrder = _sortingGroup.sortingOrder;
foreach (UnitySlot slot in _armature.GetSlots())
{
if (slot.childArmature != null)
{
var childArmatureProxy = slot.childArmature.proxy as UnityArmatureComponent;
childArmatureProxy._sortingGroup =
childArmatureProxy.GetComponent <UnityEngine.Rendering.SortingGroup>();
if (childArmatureProxy._sortingGroup == null)
{
childArmatureProxy._sortingGroup = childArmatureProxy.gameObject
.AddComponent <UnityEngine.Rendering.SortingGroup>();
}
childArmatureProxy._sortingGroup.sortingLayerName = _sortingLayerName;
childArmatureProxy._sortingGroup.sortingOrder = _sortingOrder;
}
}
}
else
{
_sortingMode = SortingMode.SortByZ;
foreach (UnitySlot slot in _armature.GetSlots())
{
if (slot.childArmature != null)
{
var childArmatureProxy = slot.childArmature.proxy as UnityArmatureComponent;
childArmatureProxy._sortingGroup =
childArmatureProxy.GetComponent <UnityEngine.Rendering.SortingGroup>();
if (childArmatureProxy._sortingGroup != null)
{
DestroyImmediate(childArmatureProxy._sortingGroup);
}
}
}
}
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
_UpdateSlotsSorting();
}
public void Test(SortingMode sortingColumn, SortingMode newSortingColumn, bool isSortingByAscendingEnabled)
{
var viewModel = new FileSystemNodesSortingViewModel(sortingColumn, isSortingByAscendingEnabled);
Assert.Equal(sortingColumn, viewModel.SortingColumn);
Assert.Equal(isSortingByAscendingEnabled, viewModel.IsSortingByAscendingEnabled);
viewModel.SortingColumn = newSortingColumn;
Assert.Equal(newSortingColumn, viewModel.SortingColumn);
viewModel.ToggleSortingDirection();
Assert.Equal(!isSortingByAscendingEnabled, viewModel.IsSortingByAscendingEnabled);
}
public List <Dish> GetDishes(SortingMode sorting)
{
switch (sorting)
{
case SortingMode.ByName:
return(SortDishesByName());
case SortingMode.ByPrice:
return(SortDishesByPrice());
default:
return(Dishes);
}
}
private void _UpdateSlotsSorting()
{
if (_armature == null)
{
return;
}
if (!isUGUI)
{
#if UNITY_5_6_OR_NEWER
if (_sortingGroup)
{
_sortingMode = SortingMode.SortByOrder;
_sortingGroup.sortingLayerName = _sortingLayerName;
_sortingGroup.sortingOrder = _sortingOrder;
#if UNITY_EDITOR
if (!Application.isPlaying)
{
EditorUtility.SetDirty(_sortingGroup);
}
#endif
}
#endif
}
//
foreach (UnitySlot slot in _armature.GetSlots())
{
var display = slot._renderDisplay;
if (display == null)
{
continue;
}
slot._SetZorder(new Vector3(display.transform.localPosition.x, display.transform.localPosition.y,
-slot._zOrder * (_zSpace + 0.001f)));
if (slot.childArmature != null)
{
(slot.childArmature.proxy as UnityArmatureComponent)._UpdateSlotsSorting();
}
#if UNITY_EDITOR
if (!Application.isPlaying && slot.meshRenderer != null)
{
EditorUtility.SetDirty(slot.meshRenderer);
}
#endif
}
}
protected override int Compare(FileViewModel x, FileViewModel y, SortingMode sortingColumn,
bool isAscending)
{
var result = sortingColumn switch
{
SortingMode.Extension => string.Compare(x.Extension, y.Extension, StringComparison.InvariantCulture),
SortingMode.Size => x.Size.CompareTo(y.Size),
SortingMode.Name => string.Compare(PreprocessFileName(x.Name), PreprocessFileName(y.Name),
StringComparison.Ordinal),
SortingMode.Date => x.LastModifiedDateTime.CompareTo(y.LastModifiedDateTime),
_ => throw new ArgumentOutOfRangeException(nameof(sortingColumn), sortingColumn, null)
};
return(isAscending ? result : -result);
}
}
public void TestSortingFileAndDirectory(bool isAscending, SortingMode sortingColumn)
{
_autoMocker.Use(true);
var directoryViewModel = _autoMocker.CreateInstance <DirectoryViewModel>();
var fileViewModel = _autoMocker.CreateInstance <FileViewModel>();
var comparer = new FileSystemNodesComparer(isAscending, sortingColumn);
var result = comparer.Compare(directoryViewModel, fileViewModel);
Assert.True(result < 0);
result = comparer.Compare(fileViewModel, directoryViewModel);
Assert.True(result > 0);
}
protected override DataTemplate OnSelectTemplate(object item, BindableObject container)
{
var contentItem = (FolderContentItem)item;
SortingMode sortingMode = AppServiceProvider.Instance.Preferences.SortingMode;
if (contentItem.Identifier == FolderContentItemIdentifier.Folder)
{
return(sortingMode switch
{
SortingMode.Name => FolderTemplate_NameOnly,
SortingMode.DateCreated => FolderTemplate_NameDateCreated,
SortingMode.DateModified => FolderTemplate_NameDateModified,
SortingMode.Size => FolderTemplate_NameSize,
_ => FolderTemplate_NameOnly,
});
public void SortSmth(ref T[] array, SortingMode mode, IComparer <T> obj, params object[] optional)
{
if (array is null)
{
throw new ArgumentNullException(nameof(array));
}
if (obj is null)
{
throw new ArgumentNullException(nameof(obj));
}
T[] newArray = (T[])array.Clone();
_sort.Sort(ref array, mode, obj, optional);
array = newArray;
}
public void TestSortingParentDirectory(bool isAscending, SortingMode sortingColumn)
{
var parentDirectoryViewModel = _autoMocker.CreateInstance <DirectoryViewModel>();
parentDirectoryViewModel.IsParentDirectory = true;
var directoryViewModel = _autoMocker.CreateInstance <DirectoryViewModel>();
var comparer = new DirectoryViewModelsComparer(isAscending, sortingColumn);
var result = comparer.Compare(parentDirectoryViewModel, directoryViewModel);
Assert.True(result < 0);
result = comparer.Compare(directoryViewModel, parentDirectoryViewModel);
Assert.True(result > 0);
}
public void TestThrows(bool isAscending, SortingMode sortingColumn)
{
_autoMocker.Use(true);
var directoryViewModel = _autoMocker.CreateInstance <DirectoryViewModel>();
var nodeViewModel = _autoMocker.CreateInstance <NodeViewModel>();
var comparer = new FileSystemNodesComparer(isAscending, sortingColumn);
void Compare() => comparer.Compare(nodeViewModel, directoryViewModel);
Assert.Throws <InvalidOperationException>(Compare);
void CompareReversed() => comparer.Compare(directoryViewModel, nodeViewModel);
Assert.Throws <InvalidOperationException>(CompareReversed);
}
public void TestCreate(SortingMode sortingColumn, bool isSortingByAscendingEnabled)
{
var viewModelMock = new Mock <IFileSystemNodesSortingViewModel>();
viewModelMock
.SetupGet(m => m.SortingColumn)
.Returns(sortingColumn);
viewModelMock
.SetupGet(m => m.IsSortingByAscendingEnabled)
.Returns(isSortingByAscendingEnabled);
var factory = new FileSystemNodeViewModelComparerFactory();
var comparer = factory.Create(viewModelMock.Object);
Assert.NotNull(comparer);
Assert.IsType <FileSystemNodesComparer>(comparer);
}
public Task<List<Ticket>> GetPrice(string token, string origin, string destination, DateTime departDate, DateTime returnDate, PeriodType period = PeriodType.Year, bool isOneWay = false, int page = 1, int limit = 30, bool isShowToAffiliates = true, SortingMode sorting = SortingMode.Price, TripClassMode tripClass = TripClassMode.Econom)
{
Contract.Requires<ArgumentNullException>(!String.IsNullOrEmpty(token), "Token can not be null or empty.");
return Task.FromResult(default(List<Ticket>));
}
public void SortMembers(SortingMode sortingMode)
{
switch (sortingMode)
{
case SortingMode.ByName:
FieldList.Sort(MemberComparisonByName);
OperationList.Sort(MemberComparisonByName);
Changed();
break;
case SortingMode.ByAccess:
FieldList.Sort(MemberComparisonByAccess);
OperationList.Sort(MemberComparisonByAccess);
Changed();
break;
case SortingMode.ByKind:
FieldList.Sort(MemberComparisonByKind);
OperationList.Sort(MemberComparisonByKind);
Changed();
break;
}
}
private void SortByMembersCount()
{
_sortingMode = SortingMode.MembersCount;
TriggerSearch();
}
private void SortByDescendantsCount()
{
_sortingMode = SortingMode.DescendantsCount;
TriggerSearch();
}
private void SortByName()
{
_sortingMode = SortingMode.Name;
TriggerSearch();
}
