вопрос о формате даты - с 16:15 до 16:00
(см. историю этого ответа, чтобы получить более сложный текст, но теперь я думаю, что читателю легче увидеть реальные командные строки).
Общие файлы, общие для всех команд ниже
$ cat a.cpp
extern int a;
int main() {
return a;
}
$ cat b.cpp
extern int b;
int a = b;
$ cat d.cpp
int b;
Связывание со статическими библиотеками
$ g++ -c b.cpp -o b.o
$ ar cr libb.a b.o
$ g++ -c d.cpp -o d.o
$ ar cr libd.a d.o
$ g++ -L. -ld -lb a.cpp # wrong order
$ g++ -L. -lb -ld a.cpp # wrong order
$ g++ a.cpp -L. -ld -lb # wrong order
$ g++ a.cpp -L. -lb -ld # right order
Компонент выполняет поиск слева направо и отмечает неразрешенные символы. Если библиотека разрешает символ, он принимает объектные файлы этой библиотеки для разрешения символа (b.o из libb.a в этом случае).
Зависимости статических библиотек друг от друга работают одинаково - библиотека, которая нуждается в символах, должна быть первой, а затем библиотекой, которая разрешает символ.
Если статическая библиотека зависит от другой библиотеки , но другая библиотека снова зависит от прежней библиотеки, есть цикл. Вы можете разрешить это, включив циклически зависимые библиотеки с помощью -( и -), например -( -la -lb -) (вам может понадобиться избежать появления парсеров, таких как -\( и -\)). Затем компоновщик выполняет поиск вложенных библиотек несколько раз, чтобы гарантировать, что зависания на велосипеде разрешены. Кроме того, вы можете указывать библиотеки несколько раз, поэтому каждый из них находится друг перед другом: -la -lb -la.
Связывание с динамическими библиотеками
$ export LD_LIBRARY_PATH=. # not needed if libs go to /usr/lib etc
$ g++ -fpic -shared d.cpp -o libd.so
$ g++ -fpic -shared b.cpp -L. -ld -o libb.so # specifies its dependency!
$ g++ -L. -lb a.cpp # wrong order (works on some distributions)
$ g++ -Wl,--as-needed -L. -lb a.cpp # wrong order
$ g++ -Wl,--as-needed a.cpp -L. -lb # right order
Здесь то же самое - библиотеки должны следуйте объектным файлам программы. Разница здесь в статических библиотеках заключается в том, что вы не должны заботиться о зависимостях библиотек друг от друга, потому что динамические библиотеки сами сортируют свои зависимости .
Некоторые недавние дистрибутивы, по-видимому, по умолчанию используют флаг компоновщика --as-needed, который обеспечивает, чтобы объектные файлы программы приходили перед динамическими библиотеками. Если этот флаг передан, компоновщик не будет ссылаться на библиотеки, которые фактически не нужны исполняемому файлу (и он обнаруживает это слева направо). Мой недавний дистрибутив archlinux по умолчанию не использует этот флаг, поэтому он не дал ошибку, чтобы не следовать правильному порядку.
Неправильно пропустить зависимость b.so от d.so при создании первого. При связывании a вам потребуется указать библиотеку, но a действительно не нуждается в самом целочисленном b, поэтому не следует заботиться о собственных зависимостях b.
Вот пример последствий, если вы пропустили определение зависимостей для libb.so
$ export LD_LIBRARY_PATH=. # not needed if libs go to /usr/lib etc
$ g++ -fpic -shared d.cpp -o libd.so
$ g++ -fpic -shared b.cpp -o libb.so # wrong (but links)
$ g++ -L. -lb a.cpp # wrong, as above
$ g++ -Wl,--as-needed -L. -lb a.cpp # wrong, as above
$ g++ a.cpp -L. -lb # wrong, missing libd.so
$ g++ a.cpp -L. -ld -lb # wrong order (works on some distributions)
$ g++ -Wl,--as-needed a.cpp -L. -ld -lb # wrong order (like static libs)
$ g++ -Wl,--as-needed a.cpp -L. -lb -ld # "right"
. Если теперь вы посмотрите на зависимости, которые имеет двоичный файл, вы заметите сам бинарный файл зависит также от libd, а не только от libb. Бинарный файл нужно будет перемотать, если позже libb зависит от другой библиотеки, если вы сделаете это так. И если кто-то загружает libb, используя dlopen во время выполнения (подумайте о загрузке плагинов динамически), вызов также не удастся. Поэтому "right" действительно должен быть wrong.
3 ответа
Вы можете указать порог и написать функцию, которая оценивает и устанавливает DateTime в соответствии с ним
var threshold = 15; //minutes
var dt = DateTime.Now.AddMinutes(-20);
//var dt = DateTime.Now;
DateTime resultDt;
DateTime thUp = dt.AddMinutes(15);
DateTime thDown = dt.AddMinutes(-15);
if (thUp.Hour != dt.Hour)
resultDt = new DateTime(dt.Year, dt.Month, dt.Day, thUp.Hour, 0, 0);
else if (thDown.Hour != dt.Hour)
resultDt = new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, 0, 0);
else
resultDt = dt;
Вы можете сделать функцию округления для округления до ближайшего часа и т. Д. И использовать совет SeM, обычно при запросе здесь вы будете показывать исходный код того, что вы уже пытались.
public static DateTime RoundDate(DateTime input)
{
var hour = input.Minutes > 30 ? input.Hour + 1 : input.Hour; //Rounding to get the nearest hour
return new DateTime(input.Year, input.Month, input.Day, hour, 0);
}
Для расчета сдвига вы можете использовать этот код
class ShiftInfo : IEquatable<ShiftInfo>
{
public ShiftInfo(TimeSpan startTime, string name)
{
this.StartTime = startTime;
this.Name = name;
}
public TimeSpan StartTime
{
get;
private set;
}
public string Name
{
get;
private set;
}
public bool Equals(ShiftInfo other)
{
return StartTime.Equals(other.StartTime);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj is ShiftInfo)
{
return this.Equals((ShiftInfo)obj);
}
return false;
}
public override int GetHashCode()
{
return StartTime.GetHashCode();
}
}
class ShiftConfig : IEnumerable<ShiftInfo>
{
private readonly ICollection<ShiftInfo> _shiftInfos;
public ShiftConfig(params ShiftInfo[] shiftInfos)
{
_shiftInfos = shiftInfos.Distinct().OrderBy(e => e.StartTime).ToList();
}
public ShiftConfig(HashSet<ShiftInfo> shiftInfos)
{
_shiftInfos = shiftInfos.OrderBy(e => e.StartTime).ToList();
}
public IEnumerator<ShiftInfo> GetEnumerator()
{
return _shiftInfos.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return _shiftInfos.GetEnumerator();
}
}
class ShiftWorkItem
{
public ShiftWorkItem(ShiftInfo shift, DateTime shiftFrom, DateTime shiftUntil, DateTime workFrom, DateTime workUntil)
{
Shift = shift;
ShiftFrom = shiftFrom;
ShiftUntil = shiftUntil;
WorkFrom = workFrom;
WorkUntil = workUntil;
}
public ShiftInfo Shift
{
get;
private set;
}
public DateTime ShiftFrom
{
get;
private set;
}
public DateTime ShiftUntil
{
get;
private set;
}
public TimeSpan ShiftDuration
{
get
{
return ShiftUntil - ShiftFrom;
}
}
public DateTime WorkFrom
{
get;
private set;
}
public DateTime WorkUntil
{
get;
private set;
}
public TimeSpan WorkDuration
{
get
{
return WorkUntil - WorkFrom;
}
}
}
static class ShiftConfigExtensions
{
public static IEnumerable<ShiftWorkItem> EnumerateShifts(this ShiftConfig config, DateTime from, TimeSpan duration)
{
return EnumerateShifts(config, from, from.Add(duration));
}
public static IEnumerable<ShiftWorkItem> EnumerateShifts(this ShiftConfig config, DateTime from, DateTime until)
{
DateTime day = from.Date.AddDays(-1);
DateTime? shiftStart = null;
ShiftInfo lastShift = null;
while (true)
{
foreach (var shift in config)
{
var shiftEnd = day.Add(shift.StartTime);
if (shiftStart != null)
{
if ((shiftStart.Value <= from && shiftEnd >= from) || (shiftStart.Value <= until && shiftEnd >= until) || (shiftStart.Value > from && shiftEnd <= until))
{
var workFrom = shiftStart.Value < from ? from : shiftStart.Value;
var workUntil = shiftEnd > until ? until : shiftEnd;
yield return new ShiftWorkItem(lastShift, shiftStart.Value, shiftEnd, workFrom, workUntil);
}
}
if (shiftEnd >= until)
{
yield break;
}
shiftStart = shiftEnd;
lastShift = shift;
}
day = day.AddDays(1);
}
}
}
Использование
public static void Main(string[] args)
{
var sc = new ShiftConfig(
new ShiftInfo(TimeSpan.FromHours(6), "early"),
new ShiftInfo(TimeSpan.FromHours(14), "late"),
new ShiftInfo(TimeSpan.FromHours(22), "night"));
Console.WriteLine(" | SHIFT | WORK ");
Console.WriteLine(" Date Shiftname | from until dur. | from until dur. ");
Console.WriteLine("======================|=========================|=========================");
foreach (var item in sc.EnumerateShifts(new DateTime(2019, 01, 01, 02, 37, 25), TimeSpan.FromHours(28.34)))
{
Console.WriteLine("{0:yyyy-MM-dd} {1,-10} | {2:HH:mm:ss} {3:HH:mm:ss} {4:0.00}h | {5:HH:mm:ss} {6:HH:mm:ss} {7:0.00}h", item.ShiftFrom.Date, item.Shift.Name, item.ShiftFrom, item.ShiftUntil, item.ShiftDuration.TotalHours, item.WorkFrom, item.WorkUntil, item.WorkDuration.TotalHours);
}
}
, который генерирует
| SHIFT | WORK
Date Shiftname | from until dur. | from until dur.
======================|=========================|=========================
2018-12-31 night | 22:00:00 06:00:00 8.00h | 02:37:25 06:00:00 3.38h
2019-01-01 early | 06:00:00 14:00:00 8.00h | 06:00:00 14:00:00 8.00h
2019-01-01 late | 14:00:00 22:00:00 8.00h | 14:00:00 22:00:00 8.00h
2019-01-01 night | 22:00:00 06:00:00 8.00h | 22:00:00 06:00:00 8.00h
2019-01-02 early | 06:00:00 14:00:00 8.00h | 06:00:00 06:57:49 0.96h
или для покрытия вашего образца
public static void Main(string[] args)
{
var sc = new ShiftConfig(
new ShiftInfo(TimeSpan.FromHours(0), "night"),
new ShiftInfo(TimeSpan.FromHours(8), "early"),
new ShiftInfo(TimeSpan.FromHours(16), "late"));
Console.WriteLine(" | SHIFT | WORK ");
Console.WriteLine(" Date Shiftname | from until dur. | from until dur. ");
Console.WriteLine("======================|=========================|=========================");
foreach (var item in sc.EnumerateShifts(new DateTime(2019, 01, 01, 15, 55, 00), TimeSpan.FromMinutes(20)))
{
Console.WriteLine("{0:yyyy-MM-dd} {1,-10} | {2:HH:mm:ss} {3:HH:mm:ss} {4:0.00}h | {5:HH:mm:ss} {6:HH:mm:ss} {7:0.00}h", item.ShiftFrom.Date, item.Shift.Name, item.ShiftFrom, item.ShiftUntil, item.ShiftDuration.TotalHours, item.WorkFrom, item.WorkUntil, item.WorkDuration.TotalHours);
}
}
мы получаем
| SHIFT | WORK
Date Shiftname | from until dur. | from until dur.
======================|=========================|=========================
2019-01-01 early | 08:00:00 16:00:00 8.00h | 15:55:00 16:00:00 0.08h
2019-01-01 late | 16:00:00 00:00:00 8.00h | 16:00:00 16:15:00 0.25h