• Extreme

    • Contents

    Extreme Class

    (A::Extreme)[final]

    This is a class containg a lot. More...

    Header: #include <a/extreme.h>
    Since: Qt 42
    Inherits: QObject and Base
    Inherited By:

    A::SubClassA, A::SubClassB, A::SubClassC, and A::SubClassD

    Note: All functions in this class are reentrant, except for extremeSignal(), which is nonreentrant. abstractBaseMemeberFunction1() is thread-safe.

    Public Types

    class InnerClass
    class InnerStruct
    class InnerTemplateClass
    enum Enum1 { EOh, EHappy, EDay }
    enum class Enum2 { Oh, Happy, Day }
    typedef Parent

    Properties

    • 1 property inherited from QObject

    Public Functions

    Extreme()
    Extreme(const Extreme & other)
    ~Extreme()
    void abstractBaseMemeberFunction1()
    void abstractBaseMemeberFunction1(int xyz)
    void baseMemberFunction1()
    void extremeOverloadedFunction(int i)
    void extremeOverloadedFunction()
    void extremeTemplateMemberFunction1()
    const Foo & foo() const
    void resetFoo()
    void setFoo(const Foo &)
    void templateMethod(T argument)
    Extreme operator+(const Extreme & other) const
    Extreme & operator=(const Extreme & other)

    Reimplemented Public Functions

    virtual void virtualBaseMemberFunction1(int) const
    • 31 public functions inherited from QObject
    • 11 public functions inherited from A::Base

    Public Slots

    void extremePublicSlot(int xyz)
    • 1 public slot inherited from QObject

    Signals

    void extremeSignal(int xyz)
    void fooChanged(const Foo & foo)

    Public Variables

    int memberVariable1
    int memberVariable3
    • 1 public variable inherited from QObject

    Static Public Members

    void extremeStaticFunction(int xyz)
    int memberVariableStatic1
    • 10 static public members inherited from QObject
    • 1 static public member inherited from A::Base

    Protected Types

    typedef ProtectedParent

    Protected Functions

    void extremeProtectedFunction(int xyz) const

    Reimplemented Protected Functions

    virtual void virtualProtecetdBaseMemberFunction1(int xyz) const
    virtual void virtualProtecetdBaseMemberFunction2(int xyz) const
    • 9 protected functions inherited from QObject
    • 3 protected functions inherited from A::Base

    Protected Slots

    void extremeProtectedSlot(int xyz)
    void virtualProtecetdSlotBaseMemberFunction1(int xyz) const
    virtual void virtualProtecetdSlotBaseMemberFunction2(int xyz) const

    Protected Variables

    int memberVariable2
    • 2 protected variables inherited from QObject

    Static Protected Members

    (preliminary) void extremeProtectedStaticFunction(int xyz)
    int memberVariableStatic2
    void lookAFriend()
    A::Extreme someFunctionRelatedToExtreme(A::Extreme a, A::Extreme b)

    Macros

    void MACRO( a, x)

    Detailed Description

    This is a class containg a lot.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    Is it already eneough filltext? I don't think so. I need more! But where can I get some ideas for a text? I have no idea. Maybe I should tell something about my past. Well there was an apple cake my grandma used to bake. Maybe I should search the recipe? It had a lot of of fruit, so I don't think it was very unhealthy. I think it's time of a linebreak.
    Now, that we are already talking about cokkies: Have you ever wondert, why there are some sortsof candy you can only buy for special holidays like christmas. While there are other sorts of cookies you can buy the whole year. I wonder who decided to sell some cookies only for certain holidays. Hmm, probably it wasn't a decision of a single person. It was was a tradicion for some cookies. But then, chockolate, coconuts and vanilla were unknown in europe for centuries. So the tradition must have evolved in the past few centuries.

    Well, I think that's eneough text for now. I probably will copy this text, even if it has no meaning for anyone. But hey, that's the idea of it.

    Member Type Documentation

    enum Extreme::Enum1

    This is the Enum1

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    ConstantValueDescription
    A::Extreme::EOh0this is Oh
    A::Extreme::EHappy1this is Happy
    A::Extreme::EDay2this is Day Ignore this

    enum class Extreme::Enum2 : int32

    This is the Enum2

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    ConstantValueDescription
    A::Extreme::Enum2::Oh0this is Oh
    A::Extreme::Enum2::Happy1this is Happy
    A::Extreme::Enum2::Day2this is Day

    typedef Extreme::Parent

    This the member function Extreme::Parent const of the Base class

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    typedef Extreme::ProtectedParent

    This the member function Extreme::ProtecetdParent const of the Base class

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Property Documentation

    foo2 : B::Foo

    This property holds this is the property foo2 of the class A::Extreme.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Access functions:

    const Foo & foo() const
    void setFoo(const Foo &)
    void resetFoo()

    Notifier signal:

    void fooChanged(const Foo & foo)

    foo : Foo

    This property holds this is the property foo of the class A::Extreme.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Access functions:

    const Foo & foo() const
    void setFoo(const Foo &)
    void resetFoo()

    Notifier signal:

    void fooChanged(const Foo & foo)

    Member Function Documentation

    Extreme::Extreme()

    This is the ctor Extreme::Extreme

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Extreme::Extreme(const Extreme & other)

    This is the copy ctor Extreme::Extreme

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text. other.

    Extreme::~Extreme()

    This is the dtor Extreme::Extreme

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    [override] void Extreme::abstractBaseMemeberFunction1()

    Some other text. To be able to get a feeling for text formating

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    Note: This function is thread-safe.

    [final override] void Extreme::abstractBaseMemeberFunction1(int xyz)

    Some other text. To be able to get a feeling for text formating

    xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    void Extreme::baseMemberFunction1()

    This the member function Extreme::baseMemberFunction1() const of the Base class

    Detailed documentation to the Extreme::baseMemberFunction1() const function with the argument.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    void Extreme::extremeOverloadedFunction(int i)

    Some other text. To be able to get a feeling for text formating

    i Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    See also abstractBaseMemeberFunction1().

    void Extreme::extremeOverloadedFunction()

    This function overloads extremeOverloadedFunction(int i).

    This function wraps around extremeOverloadedFunction(int) and passes 42

    [protected] void Extreme::extremeProtectedFunction(int xyz) const

    Some other text. To be able to get a feeling for text formating

    extremeProtectedFunction xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [protected slot] void Extreme::extremeProtectedSlot(int xyz)

    Some other text. To be able to get a feeling for text formating

    extremeProtectedSlot xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [static protected] void Extreme::extremeProtectedStaticFunction(int xyz)

    This function is under development and is subject to change.

    Some other text. To be able to get a feeling for text formating

    extremeProtectedStaticFunction xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [slot] void Extreme::extremePublicSlot(int xyz)

    Some other text. To be able to get a feeling for text formating

    extremePublicSlot xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [signal] void Extreme::extremeSignal(int xyz)

    Some other text. To be able to get a feeling for text formating

    extremeSignal xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    Warning: This function is not reentrant.

    [static] void Extreme::extremeStaticFunction(int xyz)

    Some other text. To be able to get a feeling for text formating

    extremeStaticFunction xyz Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    void Extreme::extremeTemplateMemberFunction1()

    This is the template function extremeTemplateMemberFunction1

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    void Extreme::templateMethod(T argument)

    This is a template method with an argument.

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [virtual override] void Extreme::virtualBaseMemberFunction1(int) const

    Reimplemented from Base::virtualBaseMemberFunction1().

    [virtual protected override] void Extreme::virtualProtecetdBaseMemberFunction1(int xyz) const

    Reimplemented from Base::virtualProtecetdBaseMemberFunction1().

    This the member function Extreme::virtualProtecetdBaseMemberFunction1(int) const of the Base class

    Detailed documentation to the Extreme::virtualProtecetdBaseMemberFunction1(int) const function with the argument xyz.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [virtual protected final override] void Extreme::virtualProtecetdBaseMemberFunction2(int xyz) const

    Reimplemented from Base::virtualProtecetdBaseMemberFunction2().

    This the member function Extreme::virtualProtecetdBaseMemberFunction1(int) const of the Base class

    Detailed documentation to the Extreme::virtualProtecetdBaseMemberFunction1(int) const function with the argument xyz.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [protected slot override] void Extreme::virtualProtecetdSlotBaseMemberFunction1(int xyz) const

    This the member function Extreme::virtualProtecetdSlotBaseMemberFunction1(int) const of the Base class

    Detailed documentation to the Extreme::virtualProtecetdSlotBaseMemberFunction1(int) const function with the argument xyz.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    [virtual protected slot override] void Extreme::virtualProtecetdSlotBaseMemberFunction2(int xyz) const

    Reimplemented from Base::virtualProtecetdSlotBaseMemberFunction2().

    Extreme Extreme::operator+(const Extreme & other) const

    This is the plus operator

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text. other.

    Extreme & Extreme::operator=(const Extreme & other)

    This is the assignment operator

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text. other.

    Member Variable Documentation

    int Extreme::memberVariable1

    This variable holds this is the static variable memberVariable1.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    int Extreme::memberVariable2

    This variable holds this is the static variable memberVariable2.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    int Extreme::memberVariable3

    This variable holds this is the static variable memberVariable3.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    int Extreme::memberVariableStatic1

    This variable holds this is the static variable memberVariableStatic1.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    int Extreme::memberVariableStatic2

    This variable holds this is the static variable memberVariableStatic2.

    Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.

    Related Non-Members

    void lookAFriend()

    Some other text. To be able to get a feeling for text formating

    Maybe a new paragraph would be also nice. This filling-text doesn't have to make sense. It joust should be a lot of it. In this case, I prefer Quantity over Quality. That's usually not a good idea when writing a documentation. But for a showcase I think this should be ok.

    A::Extreme someFunctionRelatedToExtreme(A::Extreme a, A::Extreme b)

    operator + for extreeme

    This function a b

    This function was introduced in Qt 42.256.

    See also lookAFriend, testhaha, and A::Extreme::abstractBaseMemeberFunction1.

    Macro Documentation

    void MACRO( a, x)

    This is a macro MACRO

    It has two arguments a and x. Some other text. To be able to get a feeling for text formating, you need a lot of text to get a feeling for it. So yeah, tadaa! Here's some text. I thnk we need a little more text. A lot more text.