По колено в коде — Говнокод.ру

Куча / Говнокод #27315

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14

?check_trace(
       begin
           %% Inject some orderings to make sure the replicant
           %% receives transactions in all states.
           %%
           %% 1. Commit some transactions before the replicant start:
           ?force_ordering(#{?snk_kind := trans_gen_counter_update, value := 5}, #{?snk_kind := state_change, to := disconnected}),
           %% 2. Make sure the rest of transactions are produced after the agent starts:
           ?force_ordering(#{?snk_kind := subscribe_realtime_stream}, #{?snk_kind := trans_gen_counter_update, value := 10}),
           %% 3. Make sure transactions are sent during TLOG replay:
           ?force_ordering(#{?snk_kind := state_change, to := bootstrap}, #{?snk_kind := trans_gen_counter_update, value := 15}),
           %% 4. Make sure some transactions are produced while in normal mode
           ?force_ordering(#{?snk_kind := state_change, to := normal}, #{?snk_kind := trans_gen_counter_update, value := 25}),
...

Какой тест )))

CHayT, 24 Марта 2021

Комментарии (3)

Куча / Говнокод #27314

+1

1
2
3
4
5
6
7
8

# PowerShell

switch ($true)
{
    ($firstNumber -gt $secondNumber) {Write-Output ("{0} > {1}" -F $firstNumber, $secondNumber)}
    ($firstNumber -eq $secondNumber) {Write-Output ("{0} == {1}" -F $firstNumber, $secondNumber)}
    ($firstNumber -lt $secondNumber) {Write-Output ("{0} < {1}" -F $firstNumber, $secondNumber)}
}

Интересный такой свитч-кейс (https://stackoverflow.com/questions/57063932/powershell-overriding-assignment-and-comparison-operators)

groser, 24 Марта 2021

Комментарии (5)

Java / Говнокод #27313

+5

1
2
3

private static String getMargin(final int size) {
        return "                                                                                                                             ".substring(0, 6 * size);
    }

Как создать пустую строку с заданной длиной...

nekkiy, 24 Марта 2021

Комментарии (31)

C++ / Говнокод #27312

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <iostream>

template<typename T>
struct CrtpBase {
    static float base_func()
    {
        std::cout << "CrtpBase::base_func(), " << typeid(T).name() << "::int_field == "
            << T::int_field << std::endl;
        return 16.0f;
    }

    static inline float x = base_func();
};

struct A: public CrtpBase<A> {
    void func_a()
    {
        base_func();
    }

    static inline int int_field = 16;
};

struct B : public CrtpBase<B> {
    void func_b()
    {
        std::cout << "B::func_b(), no CrtpBase<B>::base_func() call" << std::endl;
    }
};


int main()
{
    A a;
    a.func_a();

    B b;
    b.func_b();
}

[temp.inst]/2:

    Unless a class template specialization is a declared specialization,

    the class template specialization is implicitly instantiated when

    the specialization is referenced in a context that requires a

    completely-defined object type or when the completeness of the

    class type affects the semantics of the program.



[temp.inst]/3:

    The implicit instantiation of a class template specialization causes

    (3.1) -- the implicit instantiation of the declarations, but not of the definitions, of

        the non-deleted class member functions, member classes, scoped member enumerations,

        static data members, member templates, and friends; and

    (3.2) -- the implicit instantiation of the definitions of deleted member functions,

        unscoped member enumerations, and member anonymous unions.



[temp.inst]/4:

    Unless a member of a templated class is a declared specialization, the specialization

    of the member is implicitly instantiated when the specialization is referenced in a

    context that requires the member definition to exist or if the existence of the definition

    of the member affects the semantics of the program; in particular, the initialization

    (and any associated side effects) of a static data member does not occur unless the

    static data member is itself used in a way that requires the definition of the static

    data member to exist.

Таким образом, по стандарту CrtpBase<B>::x не должен быть инициализирован, поскольку он нигде не used in a way that requires the definition of the static data member to exist. Правильные компиляторы (gcc и clang) это понимают и компилируют код, а вот Visual Studio зачем-то пытается инициализировать CrtpBase<B>::x и нон-конформно ломается.

PolinaAksenova, 24 Марта 2021

Комментарии (179)

C++ / Говнокод #27311

+3

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

// A registrator class.
// To register a Parents <- Child relation user must derive their type from
// the correct specialization of this class
template<typename Child, typename... Parents>
struct registrator {
private:
    // The registerRelation() function would be called during dynamic initialization of this
    // static storage duration variable.
    static volatile inline detail::registratorType _registrator
        = RelationManager::registerRelation<Child, Parents...>();

protected:
    /*
    [basic.start.dynamic]/6:
        It is implementation-defined whether the dynamic initialization of a non-block inline variable
        with static storage duration is sequenced before the first statement of main or is deferred.
        If it is deferred, it strongly happens before any non-initialization odr-use of that variable.
    [basic.start.dynamic]/4:
        A non-initialization odr-use is an odr-use ([basic.def.odr]) not caused directly or indirectly
        by the initialization of a non-block static or thread storage duration variable.
    By odr-using the _registrator here we are making sure that any Child constructor is odr-using it as well,
    thus guaranteeing that the compiler would call registerRelation() strongly before the Child constructor
    */
    constexpr registrator() noexcept
    {
        // Taking an address of a variable, even in a discarded statement, is an odr-use
        (void)&_registrator;
    }

private:
    /*
    If registrator() constructor is never 'non-initialization odr-used'
    (no Child objects are created besides non-local static ones), then the only
    instantiation of the registrator class is an implicit instantiation caused by deriving Child;

    [temp.inst]/3:
        The implicit instantiation of a class template specialization causes
        (3.1) -- the implicit instantiation of the declarations, but not of the definitions, of
            the non-deleted class member functions, member classes, scoped member enumerations,
            static data members, member templates, and friends; and
        (3.2) -- the implicit instantiation of the definitions of deleted member functions,
            unscoped member enumerations, and member anonymous unions.

    [basic.def.odr]/8:
        [...] A constructor for a class is odr-used as specified in [dcl.init].
    (In other words, "A constructor (including default constructors) for a class
     is odr-used by the initialization that selects it.")

    The problem is that if there is no Child() constructor calls, then the compiler is not required to
    even DEFINE our registrator() constructor, and since there is only one odr-use of the static inline
    variable _registrator, the compiler is not required to generate a definition for it as well. And since
    it is not generating a definition, the initialization is also not generated.

    But [temp.inst]/3.2 requires that any implicit instantiation of a class template also
    causes the DEFINITION instantiation of an unscoped member enumerations. Next,
    [dcl.spec.auto.general]/12:
        Return type deduction for a templated entity that is a function or function template
        with a placeholder in its declared type occurs when the definition is instantiated
        even if the function body contains a return statement with a non-type-dependent operand
    Thus, using sizeof(*_force_registrator_instantiation()) causes the implicit instantiation
    of definition of _force_registrator_instantiation(), and since this function is odr-using _registrator,
    its definition (and initialization) is also generated.

    The only problem is that by [basic.start.dynamic]/6 the implementation MAY defer the dynamic
    initialization of _registrator to the point where it is 'non-initialization odr-used', and since without
    the Child() constructor call we don't have any way to non-initialization odr-use it, we also have no way to
    make sure that the compiler invokes registerRelation() before main() or before any other point of execution.
    The good news, though, is that all three modern compilers obediently initializes _registrator before the first
    statement of main().
    */
    static auto _force_registrator_instantiation()
    {
        return &_registrator;
    }

    enum {
        _ROTARTSIGER_ETAITNATSNI = sizeof(*_force_registrator_instantiation()),
    };
};

PolinaAksenova, 23 Марта 2021

Комментарии (51)

JavaScript / Говнокод #27310

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

$(".reg_button").on("click", function(){
    console.log("hello world jquery");
    $(".main").css("display", "none");
    $(".register-main").css("display", "block");
    $(`input[type="text"]`).css("width", "14vw");
    $(`input[type="password"]`).css("width", "14vw");
    $(`input[type="email"]`).css("width", "14vw");
     // Обработка нажатия на кнопку регистрации
});
const recovery = {
  login: "",
  email: "",
}
const regExp = {
  login: /^[a-z0-9_-]{5,20}$/,
  pass: /^[A-Za-z0-9_-]{6,16}$/,
  email: /^[A-Z0-9._%+-]+@[A-Z0-9-]+.+.[A-Z]{2,4}$/i,
}
const state = {
  reg: {
    login: "",
    pass: "",
    email: "",
    agreement: ""
  },
  auth: {
    login: "",
    pass: "",
    agreement: false
  }
  }
$(".back").on("click", function() {
    $(".register-main").css("display", "none");
    $(".main").css("display", "flex");
    $(`input[type="text"]`).css("width", "21.5vw");
    $(`input[type="password"]`).css("width", "21.5vw");
    // Обработка нажатия на кнопку "Назад"
});
$(".auth_forgotPassword").on("click", function() {
  console.log("Система восстановления пароля в разработке.")
 /* $(".main").css("display", "none");
  $(".recovery").css("display", "block");
  $(".recovery-step-one").css("display", "block");
  $(`input[type="text"]`).css("width", "14vw");
  $(`input[type="password"]`).css("width", "14vw"); */
})
$(".recovery-back").on("click", function() {
  $(".recovery").css("display", "none");
  $(".recovery-step-one").css("display", "none");  
  $(".main").css("display", "flex");                 // кнопка назад, в восстановления пароля.
  $(`input[type="text"]`).css("width", "21.5vw");
  $(`input[type="password"]`).css("width", "21.5vw");
})
$(".recovery-back2").on("click", function() {
  $(".recovery-step-two").css("display", "none");
  $(".recovery").css("display", "block");     
  $(".recovery-step-one").css("display", "block");                  // кнопка назад, в восстановления пароля.
  $(`input[type="text"]`).css("width", "14vw");
  $(`input[type="password"]`).css("width", "14vw");
})
// $(".recovery-button").on("click", function() {
  /*recovery.login = $(".step_login").val()
  recovery.email = $(".step_email").val()
  alt.emit("click:recovery")
  if(recovery.login == "" || recovery.email == "" )
  {
    console.log("Необходимые поля пустые!")
  }
  else {
  alt.on("recovery-step-two", (args) => {
  if(args == true) {
    $(".recovery-step-one").css("display", "none");
    $(".recovery-step-two").css("display", "block");
  }
  else {
    console.log("Введены неверные данные или аккаунта с такой почтой не существует.")
  }
  })
  }
  */
// })
$(".recovery_button2").on("click", function() {
  $(".recovery-step-two").css("display", "none");
  $(".recovery-step-three").css("display", "block");
})
$('.button-wrap').on("click", function(){
  $(this).toggleClass('button-active');
  if ($(this).hasClass('button-active')) {
    localStorage.checkbox = 1
    
  } else {
    localStorage.checkbox = 0
  }
  console.log(localStorage.checkbox)
});
$(".confirm-back2").on("click", () => {
  $(".authentication").css("display", "none");

Логика работы меню авторизации :)
Собственно первая моя верстка была, как и использование jquery)

Seagate, 22 Марта 2021

Комментарии (5)

C++ / Говнокод #27309

+3

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

template<typename T>
struct [[nodiscard]] InplacePointerGuard {
    InplacePointerGuard(T *& ptr_) : ptr(ptr_) {}
    ~InplacePointerGuard()
    {
        if (ptr != nullptr) {
            ptr->~T();
        }
    }

    T *& ptr;
};

template<typename EventType, typename... Args>
bool publishEmplace(Args &&... args) const
{
    static_assert((std::is_base_of_v<Event, EventType> && std::is_convertible_v<const EventType *, const Event *>),
                  "EventType must be a public subtype of Event");
    auto typeIdx = Event::getStaticIndex<EventType>();

    std::aligned_storage_t<sizeof(EventType), alignof(EventType)> eventStorage;
    EventType *eventConstructed = nullptr;
    auto guard = InplacePointerGuard(eventConstructed);

    publishEmplaceImpl<EventType>(typeIdx, eventStorage, eventConstructed, std::forward<Args>(args)...);

    return eventConstructed != nullptr;
}

template<typename EventType, typename... Args>
static EventType *constructEvent(std::aligned_storage_t<sizeof(EventType), alignof(EventType)> & eventStorage,
                                 Args &&... args)
{
    return std::launder(new(&eventStorage) EventType(std::forward<Args>(args)...));
}

template<typename EventType, typename... Args>
void publishEmplaceImpl(const std::type_index & typeIdx,
                        std::aligned_storage_t<sizeof(EventType), alignof(EventType)> & eventStorage,
                        EventType *& eventConstructed,
                        Args &&... args) const
{
    if (auto it = callbacks.find(typeIdx); it != callbacks.end()) {
        for (const auto & [subId, callback] : it->second) {
            if (!eventConstructed) {
                eventConstructed = constructEvent<EventType>(eventStorage, std::forward<Args>(args)...);
            }
            callback(*eventConstructed);
        }
    }

    auto range = EventsRelation::RelationManager::getParentsRange(typeIdx);
    for (auto it = range.first; it != range.second; ++it) {
        if (!eventConstructed) {
            publishEmplaceImpl<EventType>(it->second, eventStorage, eventConstructed, std::forward<Args>(args)...);
        } else {
            publishImpl(it->second, *eventConstructed);
        }
    }
}

PolinaAksenova, 22 Марта 2021

Комментарии (66)

C++ / Говнокод #27307

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

namespace detail {
    template<entity_event_t Event>
    struct EventHasEntityStateConstructor {
        // Sanity check
        static_assert(static_cast<int32_t>(Event) >= 0
                      && static_cast<int32_t>(Event) < ENTITY_EVENTS_COUNT);

    private:
        struct TwoChar {
            char a, b;
        };

        template<typename T>
        constexpr static TwoChar _check(
            decltype(
                T(std::declval<const entityState_t &>())
            )*
        );

        template<typename T>
        constexpr static char _check(...);

    public:
        constexpr inline static bool value = (sizeof(_check<EntityEvent<Event>>(nullptr)) == sizeof(TwoChar));
    };

    template<typename BusT, entity_event_t Event>
    bool defaultEntityEventPublisher(const BusT & bus, const entityState_t & eventEntity)
    {
        static_assert(EventHasEntityStateConstructor<Event>::value,
                      "defaultEntityEventFactory<Event>() instantiated for a custom\n"
                      "event that does not have a (const entityState_t & eventEntity) constructor.\n"
                      "This should not happen (you'll get a more obscured compiler error anyway)!");
        return bus.publishEmplace<EntityEvent<Event>>(eventEntity);
    }

    template<typename BusT, typename T, T... Is>
    constexpr std::array<EntityEventPublisherPtr<BusT>, sizeof...(Is)>
        createDefaultEntityEventFactories(std::integer_sequence<T, Is...>)
    {
        return {
            [](auto i) -> EntityEventPublisherPtr<BusT> {
                if constexpr (EventHasEntityStateConstructor<static_cast<entity_event_t>(i.value)>::value) {
                    return &defaultEntityEventPublisher<BusT, static_cast<entity_event_t>(i.value)>;
                } else {
                    return nullptr;
                }
            }(std::integral_constant<T, Is>{})...
        };
    }
}

// An (event_number -> EntityState<event_number> 'publishing factory' function) mapping;
// if event N could not be constructed from a single entityState_t reference
// then this table would contain nullptr at the index N
template<typename BusT>
const std::array<EntityEventPublisherPtr<BusT>, ENTITY_EVENTS_COUNT> & getDefaultEntityEventsPublishers() noexcept
{
    static auto factories = detail::createDefaultEntityEventFactories<BusT>(std::make_integer_sequence<int32_t, ENTITY_EVENTS_COUNT>());
    return factories;
}

template<typename BusT>
EntityEventPublisherPtr<BusT> tryGetDefaultEntityEventPublisher(entity_event_t event) noexcept
{
    auto eventNum = static_cast<int32_t>(event);
    if (eventNum >= 0 && eventNum < ENTITY_EVENTS_COUNT) {
        return getDefaultEntityEventsPublishers<BusT>()[eventNum];
    } else {
        return nullptr;
    }
}

PolinaAksenova, 21 Марта 2021

Комментарии (10)

Java / Говнокод #27306

+1

1

Class HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor

https://javadoc.io/doc/org.aspectj/aspectjweaver/1.8.10/org/aspectj/weaver/patterns/HasThisTypePatternTriedToSneakInSomeGene ricOrParameterizedTypePatternMatchingStu ffAnywhereVisitor.html

6oHo6o, 21 Марта 2021

Комментарии (23)

C++ / Говнокод #27305

−1

1
2
3
4
5
6
7
8
9

enum class NodeFlags : int {
    None               = 0,
    Let                = 1 << 0,
// ...
}

contextFlags &= ~flag;

// error C2675: unary '~': 'NodeFlags' does not define this operator or a conversion to a type acceptable to the predefined operator

Кому нужны такие гавно-компиляторы? которые даже не в состоянии привети четко прописанные типы?

ASD_77, 20 Марта 2021

Комментарии (29)

Говнокод: по колено в коде.