Кресты / Говнокод #23980 Ссылка на оригинал

0

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
  26. 26
  27. 27
  28. 28
  29. 29
  30. 30
  31. 31
  32. 32
  33. 33
  34. 34
  35. 35
  36. 36
  37. 37
  38. 38
  39. 39
  40. 40
  41. 41
  42. 42
  43. 43
  44. 44
  45. 45
  46. 46
  47. 47
  48. 48
  49. 49
  50. 50
  51. 51
  52. 52
  53. 53
  54. 54
  55. 55
  56. 56
  57. 57
  58. 58
  59. 59
  60. 60
  61. 61
  62. 62
  63. 63
  64. 64
  65. 65
  66. 66
  67. 67
  68. 68
  69. 69
  70. 70
  71. 71
  72. 72
  73. 73
  74. 74
  75. 75
  76. 76
  77. 77
  78. 78
  79. 79
  80. 80
  81. 81
  82. 82
  83. 83
  84. 84
  85. 85
  86. 86
  87. 87
  88. 88
  89. 89
class NTPTime {
public:
	static NTPTime getInvalidTime() { NTPTime t; t.setInvalid(); return t; }

public:
	NTPTime() : m_Time(0) {}
	NTPTime(const uint64_t time) : m_Time(time) {}
	NTPTime(const uint32_t sec, const uint32_t frac)
	  : m_Time(0)
	{
		this->set(sec, frac);
	}

	NTPTime(const boost::posix_time::ptime& timestamp);

public: // Assignment operators
	NTPTime& operator=(const uint64_t u) { m_Time = u; return *this; }
	NTPTime& operator+= (const NTPTime& Q) { m_Time += Q.m_Time; return *this; }
	NTPTime& operator-= (const NTPTime& Q) { m_Time -= Q.m_Time; return *this; }

public: // Cast operators
	operator uint64_t() { return this->m_Time; }

public: // comparison operators
	bool operator==(const NTPTime& other) const { return (m_Time == other.m_Time); }
	bool operator!=(const NTPTime& other) const { return (m_Time != other.m_Time); }
	bool operator>=(const NTPTime& other) const { return (m_Time >= other.m_Time); }
	bool operator>(const NTPTime& other) const { return (m_Time > other.m_Time); }
	bool operator<=(const NTPTime& other) const { return (m_Time <= other.m_Time); }
	bool operator<(const NTPTime& other) const { return (m_Time < other.m_Time); }

public: // arithmetic operators
	NTPTime operator+(const NTPTime& other) const
	{
		NTPTime result = *this;
		result += other;
		return result;
	}

	NTPTime operator-(const NTPTime& other) const
	{
		NTPTime result = *this;
		result -= other;
		return result;
	}

public:
	uint32_t getSeconds() const { return ((uint32_t)(m_Time >> 32));}
	uint32_t getFracSeconds() const { return ((uint32_t)(m_Time & 0xFFFFFFFF));}
	uint32_t getMilliseconds() const { const uint64_t t = 1000*m_Time ; return (uint32_t)((t>>32)&0xFFFFFFFF);}
	uint32_t getMicroseconds() const { const uint64_t t = 125*m_Time/536871; return (uint32_t)(t&0xFFFFFFFF);}
	void getTime_s_us(uint32_t& sec, uint32_t& us) const { sec = getSeconds(); us = getFracSeconds()/4295;}
	uint64_t getTime(void) const {return m_Time;}

public:
	/// set the time in seconds and microseconds (micros: 0..1000 0000)
	///This routine uses the factorization: 2^32/10^6 = 4096 + 256 - 1825/32
	void setTime_s_us(const uint32_t sec, const uint32_t us) { m_Time = ((uint64_t)sec<<32) | ((us<<12)-((us*1852)>>5)+(us<<8));}

	void set(const uint64_t& u) {m_Time = u;}
	void set(const uint32_t sec, const uint32_t frac)
	{
		m_Time = sec;
		m_Time = m_Time<<32;
		m_Time |= frac;
	}

	void setInvalid() { m_Time = uint64_t(NOT_A_DATE_TIME) << 32; }

	/// 2^32/10^6 = 4096 + 256 - 1825/32
	void setMicroseconds(const uint32_t u) { const uint64_t t = ((uint64_t)u * 1825) >> 5; m_Time = ((uint64_t)u << 12) + ((uint64_t)u << 8) - t;}
	void setMicroseconds(const uint64_t u) { const uint64_t t = (u * 1825) >> 5; m_Time = (u << 12) + (u << 8) - t;}
	void setMilliseconds(const uint32_t u) { m_Time = (uint64_t)u * 536870912 / 125;}
	void addMilliseconds(const uint32_t u) { NTPTime t; t.setMilliseconds(u); *this += t;}
	void addMicroseconds(const uint32_t u) { NTPTime t; t.setMicroseconds(u); *this += t;}

protected:
	static double round(const double v);

private:
	static const double secondFractionNTPtoNanoseconds;
	static const double nanosecondsToSecondFractionNTP;
	static const uint32_t NOT_A_DATE_TIME;
	static const uint64_t NOT_A_DATE_TIME64;
	static const boost::posix_time::ptime m_epoch;

protected:
	uint64_t m_Time; ///< NTP time in 1/2^32 seconds (~233 ps)
}; // NTPTime

Чуть г-на и несколько комментов удалил, чтоб влезло. Чтоб понятно было, m_Time хранит время в единицах 1/2^32 сек.

Запостил: elapidae elapidae, (Updated )

Комментарии (17) RSS

    • ava elapidae # Ссылка на оригинал 0 ⇈

      11 стандарт, однако...

      #include <chrono>
#include <iostream>

using namespace std;
using namespace std::chrono;

int main( int, char** )
{
    using NTP_ratio = std::ratio<1, 0xFFFFFFFF>;
    using NTP_t = chrono::duration<int64_t,NTP_ratio>;    
    NTP_t three_sec(0x300000000);
    cout << duration_cast<seconds>(three_sec).count() << endl;
    return 0;
}

      см. https://habrahabr.ru/post/324984/

      Антипаттерн "magic number", например, это: "(uint64_t)u * 536870912 / 125" и это "t = 125*m_Time/536871; return (uint32_t)(t&0xFFFFFFFF);"
      Не делайте так...
      Ответить

      • ava Dummy00001 # Ссылка на оригинал 0 ⇈

        если считать не умеешь, и не знаешь чего пытается достичь код - то все будет казатся magic, не только числа.

        0.5 минуты размышлений что пытается делать код - и почитав комментарий - и я уже знаю смысл 2/3 магических чисел.

        да магические константы говно. кто сказал что в часу 60 минут?? гавно!! надо исправить и заставить учебники писать, например, что "в часу Locale::Time::HOUR_MAX_MINUTE минут". и жизнь на планете сразу станет лучше! [...] и сколько в километре метров?.. правильно! - ISOStandard::NumberSystem::KILOMETER_MAX _METER. а все недоделаные кто ответили "1000" - всех немедленно уволить.
        Ответить

      • ava SemaReal # Ссылка на оригинал 0 ⇈

        >>sleep_for(5s);
        плюсы превращаются в руби

        >> мы в sleep передаем секунды или миллисекунды?
        а слабо ман посмотреть?
        Ответить

        • ava bormand # Ссылка на оригинал 0 ⇈

          > слабо ман посмотреть
          Дык проблема не в том, что сложно глянуть, что там принимает функция. Проблема в константах и переменных. Без типизации приходится их писать как delay_us, interval_ms или timeout_s, иначе легко запутаться и забыть сконвертить.
          Ответить

          • ava SemaReal # Ссылка на оригинал 0 ⇈

            Дык венгерка же

            secTimeout
            dolSalary
            cchSize
            bytSize

            См Спольски let the wrong code look wrong
            Ответить

          • ava Dummy00001 # Ссылка на оригинал 0 ⇈

            в данном контексте, константы это мелочь. `sleep( get_timeout() )` - красивые префиксы для констант - коренной проблемы не решают.

            а коренная проблема: интерфейсы учить надо, это часть работы программиста.

            и для продвинутых: сам педрило криворукое наплодило кривых интерфейсов, несчётное множество типов и тучи абсратных констант - сам мучайся (и учись на ошибках). на язык или иде жаловатся - это дешёвая отмазка.

            у меня буквально был пример двух сетевых прикладух перед глазами. в одной задержки и таймауты в каких не попади юнитах (включая, ёпвашу, jiffies), с багами как минимум раз в месяц. в другой какой-то простой паря со светлой голово стандартизировал все в секунды - с плавающей точкой - и в принципе проблем ни разу не было.
            Ответить

  • ava 1024-- # Ссылка на оригинал 0 

    > const uint64_t t = ((uint64_t)u * 1825) >> 5; m_Time = ((uint64_t)u << 12) + ((uint64_t)u << 8) - t;

    Подобный пердолинг с числами ещё актуален в наше время?
    Ответить

Добавить комментарий

Где здесь C++, guest?!

    А не использовать ли нам bbcode?

    ↑
    8
    ↓