commit 95007c0b936a01deac63745ab8dad2ec96befd59 Author: Edouard DUPIN Date: Fri Dec 6 16:17:42 2013 +0100 [DEV] add first exml documentation diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0d20b64 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*.pyc diff --git a/base.css b/base.css new file mode 100644 index 0000000..aa94d74 --- /dev/null +++ b/base.css @@ -0,0 +1,131 @@ + +html { + display: block; +} + +body { + font-family: 'Ubuntu',Tahoma,sans-serif; + padding-top: 40px; + padding-bottom: 40px; + font-size: 15px; + line-height: 150%; + margin: 0; + color: #333333; + background-color: #ffffff; + display: block; + margin-left: 250px; + margin-right: 50px; +}; + +.container{ + width:940px; + margin-right: auto; + margin-left: auto; + display: block; +}; + +.navbar { + z-index: 1; + overflow: visible; + color: #ffffff; + display: block; +} + +.navbar div { + display: block; + margin-left: 5px; + margin-right: 5px; +} + +.navbar-fixed-top { + width:210px; + display: block; + position: fixed; + padding-top: 0px; + top: 0; + height: 100%; + right: 0; + left: 0; + margin-bottom: 0; + background-color: #d44413; + border: 1px solid #c64012; + font-size: 15px; + font-weight: 200; + color: #ffffff; + text-shadow: 0 1px 0 #ce4213; + padding: 10px 20px 10px; + margin-left: -20px; + overflow:scroll; + overflow-x:hidden; +} +/* +.navbar ul { + font-size: 15px; +}; +*/ +h1, h2, h3, h4, h5, h6 { + display: block; + margin: 10px 0; + font-family: inherit; + font-weight: bold; + line-height: 1; + color: inherit; + text-rendering: optimizelegibility; +} + +p { + margin: 0 0 10px; + display: block; +} + +pre { + #margin-left: 20px; + display: block; + padding: 9.5px; + margin: 0 0 10px; + font-size: 13px; + line-height: 20px; + word-break: break-all; + word-wrap: break-word; + white-space: pre; + white-space: pre-wrap; + background-color: #f5f5f5; + border: 1px solid #ccc; + border: 1px solid rgba(0, 0, 0, 0.15); + border-radius: 4px; +} + + + +.code-function { + text-decoration:none; + color:#09857e; + font-weight:bold; +} + +.code-type { + text-decoration:none; + color:#376d0a; + font-weight:bold; +} + +.code-argument { + text-decoration:none; + color:#B80000; + font-weight:bold; +} + +.code-number { + text-decoration:none; + color:#007b00; +} + +.code-keyword { + text-decoration:none; + color:#215eb8; + font-weight:bold; +} +.code-storage-keyword { + text-decoration:none; + color:#466cb4; +} \ No newline at end of file diff --git a/etk__Archive.html b/etk__Archive.html new file mode 100644 index 0000000..0212943 --- /dev/null +++ b/etk__Archive.html @@ -0,0 +1,235 @@ + + + + + etk Library + + + +
+
+

etk Library

+
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Archive

    +
    +

    Synopsis:

    +
    ++                       Archive      (const std::string & _fileName);
    +                      ~Archive      (void);
    +  const std::string &  getFileName  (void);
    +  int32_t              size         (void);
    +  const std::string &  getName      (int32_t _id);
    +  const Content &      getContent   (int32_t _id);
    +  const Content &      getContent   (const std::string & _key);
    +  bool                 exist        (const std::string & _key);
    +  void                 open         (const std::string & _key);
    +  void                 close        (const std::string & _key);
    +  void                 display      (void);
    +  static Archive *     load         (const std::string & _fileName);
    #  void                 loadFile     (int32_t _id);
    + + +

    Object Hierarchy:

    +
    +etk::Archive
+    +--> etk::archive::Zip
+
    +
    +

    Detail:

    +

    etk::Archive ()

    + +
    +Archive(const std::string & _fileName);
    +
    +
    + +
    +

    etk::~Archive ()

    + +
    +~Archive(void);
    +
    +
    + +
    +

    getFileName ()

    + +
    +const std::string & getFileName(void);
    +
    +Get the current file name. +
    +
    + +
    +

    size ()

    + +
    +int32_t size(void);
    +
    +Get the number of elements +
    +
    + +
    +

    getName ()

    + +
    +const std::string & getName(int32_t _id);
    +
    +Get the File name of the ID +
    +
    + +
    +

    getContent ()

    + +
    +const Content & getContent(int32_t _id);
    +
    +Get the File name of the ID +
    +
    + +
    +

    getContent ()

    + +
    +const Content & getContent(const std::string & _key);
    +
    +Get the File name of the ID +
    +
    + +
    +

    exist ()

    + +
    +bool exist(const std::string & _key);
    +
    +Check if a file exist +
    +
    + +
    +

    open ()

    + +
    +void open(const std::string & _key);
    +
    +Load the specific file in the memory +
    +
    + +
    +

    close ()

    + +
    +void close(const std::string & _key);
    +
    +Un-Load the specific file from the memory +
    +
    + +
    +

    display ()

    + +
    +void display(void);
    +
    +Display all Element in the archive +

    + +
    +

    etk::load ()

    + +
    +static Archive * load(const std::string & _fileName);
    +
    +Load an Achive with a specific name. +
    +
    + +
    +

    loadFile ()

    + +
    +void loadFile(int32_t _id);
    +
    +Request the load in memory of the concerned file. +
    +
    + +
    +
    + + diff --git a/etk__Archive__Content.html b/etk__Archive__Content.html new file mode 100644 index 0000000..eb7e81a --- /dev/null +++ b/etk__Archive__Content.html @@ -0,0 +1,143 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Archive::Content

    +
    +

    Synopsis:

    +
    ++  void                 increaseRef     (void);
    +  void                 decreaseRef     (void);
    +  int32_t              getNumberOfRef  (void);
    +  int32_t              getTheoricSize  (void);
    +                       Content         (int32_t _basicSize);
    +  int32_t              size            (void);
    +  void *               data            (void);
    +  std::vector<char> &  getDataVector   (void);
    + + +

    Detail:

    +

    increaseRef ()

    + +
    +void increaseRef(void);
    +
    +
    + +
    +

    decreaseRef ()

    + +
    +void decreaseRef(void);
    +
    +
    + +
    +

    getNumberOfRef ()

    + +
    +int32_t getNumberOfRef(void);
    +
    +
    + +
    +

    getTheoricSize ()

    + +
    +int32_t getTheoricSize(void);
    +
    +
    + +
    +

    etk::Archive::Content ()

    + +
    +Content(int32_t _basicSize);
    +
    +
    + +
    +

    size ()

    + +
    +int32_t size(void);
    +
    +
    + +
    +

    data ()

    + +
    +void * data(void);
    +
    +
    + +
    +

    getDataVector ()

    + +
    +std::vector<char> & getDataVector(void);
    +
    +
    + +
    +
    + + diff --git a/etk__BaseNoise.html b/etk__BaseNoise.html new file mode 100644 index 0000000..63ae7af --- /dev/null +++ b/etk__BaseNoise.html @@ -0,0 +1,106 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::BaseNoise

    +
    +

    Synopsis:

    +
    ++        BaseNoise  (ivec2 _size,
                         float _min,
                         float _max);
    +       ~BaseNoise  (void);
    +  float get        (int32_t _x,
                         int32_t _y);
    + + +

    Detail:

    +

    etk::BaseNoise ()

    + +
    +BaseNoise(ivec2 _size,
+          float _min,
+          float _max);
    +
    +
    + +
    +

    etk::~BaseNoise ()

    + +
    +~BaseNoise(void);
    +
    +
    + +
    +

    get ()

    + +
    +float get(int32_t _x,
+          int32_t _y);
    +
    +
    + +
    +
    + + diff --git a/etk__Buffer.html b/etk__Buffer.html new file mode 100644 index 0000000..09f817b --- /dev/null +++ b/etk__Buffer.html @@ -0,0 +1,434 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Buffer

    +
    +

    Synopsis:

    +
    ++                       Buffer            (int32_t _count);
    +                       Buffer            (const etk::Buffer & _obj);
    +                      ~Buffer            (void);
    +  bool                 dumpIn            (etk::FSNode & _file);
    +  bool                 dumpFrom          (etk::FSNode & _file);
    +  etk::Buffer &        operator=         (const etk::Buffer & _obj);
    +  int8_t               operator[]        (int32_t _pos);
    +  int8_t &             get               (int32_t _pos);
    +  int32_t              get               (int32_t _pos,
                                               UChar & _value,
                                               charset_te _charset);
    +  std::vector<int8_t>  get               (int32_t _pos,
                                               int32_t _nbElement);
    +  void                 push_back         (const int8_t & _item);
    +  void                 insert            (int32_t _pos,
                                               const int8_t & _item);
    +  void                 insert            (int32_t _pos,
                                               std::vector<int8_t> & _items);
    +  void                 insert            (int32_t _pos,
                                               int8_t * _items,
                                               int32_t _nbElement);
    +  void                 replace           (int32_t _pos,
                                               const int8_t & _item);
    +  void                 replace           (int32_t _pos,
                                               int32_t _nbRemoveElement,
                                               std::vector<int8_t> & _items);
    +  void                 replace           (int32_t _pos,
                                               int32_t _nbRemoveElement,
                                               int8_t * _items,
                                               int32_t _nbElement);
    +  void                 remove            (int32_t _pos,
                                               int32_t _nbRemoveElement);
    +  void                 pop_back          (void);
    +  void                 clear             (void);
    +  int8_t &             getDirect         (int32_t _realElementPosition);
    +  int32_t              size              (void);
    -  void                 changeAllocation  (int32_t _newSize);
    -  bool                 gapMove           (int32_t _pos);
    -  bool                 gapResize         (int32_t _pos,
                                               int32_t _newGapLen);
    -  int32_t              gapSize           (void);
    -  void                 gapCheckMaxSize   (void);
    + + +

    Description:

    +/** +* @brief Buffer classes. Designed for access o +*/

    Detail:

    +

    etk::Buffer ()

    + +
    +Buffer(int32_t _count);
    +
    +Create an empty vector +
    +
    + +
    +

    etk::Buffer ()

    + +
    +Buffer(const etk::Buffer & _obj);
    +
    +Re-copy constructor (copy all needed data) +
    +
    + +
    +

    etk::~Buffer ()

    + +
    +~Buffer(void);
    +
    +Destructor of the current Class +

    + +
    +

    dumpIn ()

    + +
    +bool dumpIn(etk::FSNode & _file);
    +
    +Save in the current file open +
    +
    + +
    +

    dumpFrom ()

    + +
    +bool dumpFrom(etk::FSNode & _file);
    +
    +Load in the current file open +
    +
    + +
    +

    operator= ()

    + +
    +etk::Buffer & operator=(const etk::Buffer & _obj);
    +
    +Re-copy operator +
    +
    + +
    +

    operator[] ()

    + +
    +int8_t operator[](int32_t _pos);
    +
    +Operator [] : Get the data at the requested position (gap abstraction done). +
    +
    + +
    +

    get ()

    + +
    +int8_t & get(int32_t _pos);
    +
    +Get a current element in the vector +
    +
    + +
    +

    get ()

    + +
    +int32_t get(int32_t _pos,
+            UChar & _value,
+            charset_te _charset);
    +
    +Get a current element in the vector +
    +
    + +
    +

    get ()

    + +
    +std::vector<int8_t> get(int32_t _pos,
+                        int32_t _nbElement);
    +
    +Get elements from a specific position. +
    +
    + +
    +

    push_back ()

    + +
    +void push_back(const int8_t & _item);
    +
    +Add at the Last position of the Vector +
    +
    + +
    +

    insert ()

    + +
    +void insert(int32_t _pos,
+            const int8_t & _item);
    +
    +Insert One item at the specify position. +
    +
    + +
    +

    insert ()

    + +
    +void insert(int32_t _pos,
+            std::vector<int8_t> & _items);
    +
    +Insert data in the buffer +
    +
    + +
    +

    insert ()

    + +
    +void insert(int32_t _pos,
+            int8_t * _items,
+            int32_t _nbElement);
    +
    +Insert data in the buffer +
    +
    + +
    +

    replace ()

    + +
    +void replace(int32_t _pos,
+             const int8_t & _item);
    +
    +Replace one element in the buffer +
    +
    + +
    +

    replace ()

    + +
    +void replace(int32_t _pos,
+             int32_t _nbRemoveElement,
+             std::vector<int8_t> & _items);
    +
    +Replace specified data. +
    +
    + +
    +

    replace ()

    + +
    +void replace(int32_t _pos,
+             int32_t _nbRemoveElement,
+             int8_t * _items,
+             int32_t _nbElement);
    +
    +Replace specified data. +
    +
    + +
    +

    remove ()

    + +
    +void remove(int32_t _pos,
+            int32_t _nbRemoveElement);
    +
    +Remove specific data in the buffer. +
    +
    + +
    +

    pop_back ()

    + +
    +void pop_back(void);
    +
    +Remove the last element of the Buffer. +

    + +
    +

    clear ()

    + +
    +void clear(void);
    +
    +Clean all the data in the buffer. +

    + +
    +

    getDirect ()

    + +
    +int8_t & getDirect(int32_t _realElementPosition);
    +
    +Get a current element in the vector (iterator system) +
    +
    + +
    +

    size ()

    + +
    +int32_t size(void);
    +
    +Get the number of element in the vector +
    +
    + +
    +

    changeAllocation ()

    + +
    +void changeAllocation(int32_t _newSize);
    +
    +Change the current allocation to the corect one (depend on the current size) +
    +
    + +
    +

    gapMove ()

    + +
    +bool gapMove(int32_t _pos);
    +
    +Move the current gap at an other position +
    +
    + +
    +

    gapResize ()

    + +
    +bool gapResize(int32_t _pos,
+               int32_t _newGapLen);
    +
    +Change The gap position and size +
    +
    + +
    +

    gapSize ()

    + +
    +int32_t gapSize(void);
    +
    +Get the current gap size. +
    +
    + +
    +

    gapCheckMaxSize ()

    + +
    +void gapCheckMaxSize(void);
    +
    +Control if the writing gap is not too big (automatic resize the buffer). +

    + +
    +
    + + diff --git a/etk__CCout.html b/etk__CCout.html new file mode 100644 index 0000000..97b5438 --- /dev/null +++ b/etk__CCout.html @@ -0,0 +1,239 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::CCout

    +
    +

    Synopsis:

    +
    ++           CCout       (void);
    +          ~CCout       (void);
    +  CCout &  operator<<  (char32_t _t);
    +  CCout &  operator<<  (size_t _t);
    +  CCout &  operator<<  (int8_t _t);
    +  CCout &  operator<<  (int16_t _t);
    +  CCout &  operator<<  (int32_t _t);
    +  CCout &  operator<<  (int64_t _t);
    +  CCout &  operator<<  (uint8_t _t);
    +  CCout &  operator<<  (uint16_t _t);
    +  CCout &  operator<<  (uint32_t _t);
    +  CCout &  operator<<  (uint64_t _t);
    +  CCout &  operator<<  (double _t);
    +  CCout &  operator<<  (float _t);
    +  CCout &  operator<<  (char * _t);
    +  CCout &  operator<<  (const char * _t);
    +  CCout &  operator<<  (char _t);
    +  CCout &  operator<<  (bool _t);
    +  CCout &  operator<<  (CStart _ccc);
    +  CCout &  operator<<  (etk::CEndl _t);
    + + +

    Detail:

    +

    etk::CCout ()

    + +
    +CCout(void);
    +
    +
    + +
    +

    etk::~CCout ()

    + +
    +~CCout(void);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(char32_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(size_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(int8_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(int16_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(int32_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(int64_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(uint8_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(uint16_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(uint32_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(uint64_t _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(double _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(float _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(char * _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(const char * _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(char _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(bool _t);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(CStart _ccc);
    +
    +
    + +
    +

    operator<< ()

    + +
    +CCout & operator<<(etk::CEndl _t);
    +
    +
    + +
    +
    + + diff --git a/etk__CEndl.html b/etk__CEndl.html new file mode 100644 index 0000000..987f632 --- /dev/null +++ b/etk__CEndl.html @@ -0,0 +1,79 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::CEndl

    +
    +

    Synopsis:

    +
    +
    + + +

    Detail:

    +

    + + diff --git a/etk__CStart.html b/etk__CStart.html new file mode 100644 index 0000000..8069c34 --- /dev/null +++ b/etk__CStart.html @@ -0,0 +1,79 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::CStart

    +
    +

    Synopsis:

    +
    +
    + + +

    Detail:

    +

    + + diff --git a/etk__Color.html b/etk__Color.html new file mode 100644 index 0000000..e42a6c9 --- /dev/null +++ b/etk__Color.html @@ -0,0 +1,316 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Color

    +
    +

    Synopsis:

    +
    ++                    Color         (void);
    +                    Color         (double _r,
                                        double _g,
                                        double _b,
                                        double _a);
    +                    Color         (float _r,
                                        float _g,
                                        float _b,
                                        float _a);
    +                    Color         (uint8_t _r,
                                        uint8_t _g,
                                        uint8_t _b,
                                        uint8_t _a);
    +                    Color         (int _r,
                                        int _g,
                                        int _b,
                                        int _a);
    +                    Color         (uint32_t _input);
    +                    Color         (const etk::Color<float> & _obj);
    +                    Color         (const etk::Color<uint8_t> & _obj);
    +                    Color         (std::string _input);
    +                   ~Color         (void);
    +  Color &  operator=     (const etk::Color & _input);
    +  bool              operator!=    (const etk::Color & _obj);
    +  bool              operator==    (const etk::Color & _obj);
    +  uint32_t          get           (void);
    +  void              set           (float _r,
                                        float _g,
                                        float _b,
                                        float _a);
    +  void              set           (uint8_t _r,
                                        uint8_t _g,
                                        uint8_t _b,
                                        uint8_t _a);
    +  void              set           (int _r,
                                        int _g,
                                        int _b,
                                        int _a);
    +  std::string       getHexString  (void);
    +  std::string       getString     (void);
    +  MY_TYPE           r             (void);
    +  MY_TYPE           g             (void);
    +  MY_TYPE           b             (void);
    +  MY_TYPE           a             (void);
    +  void              setR          (MY_TYPE _r);
    +  void              setG          (MY_TYPE _g);
    +  void              setB          (MY_TYPE _b);
    +  void              setA          (MY_TYPE _a);
    + + +

    Detail:

    +

    etk::Color ()

    + +
    +Color(void);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(double _r,
+      double _g,
+      double _b,
+      double _a);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(float _r,
+      float _g,
+      float _b,
+      float _a);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(uint8_t _r,
+      uint8_t _g,
+      uint8_t _b,
+      uint8_t _a);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(int _r,
+      int _g,
+      int _b,
+      int _a);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(uint32_t _input);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(const etk::Color<float> & _obj);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(const etk::Color<uint8_t> & _obj);
    +
    +
    + +
    +

    etk::Color ()

    + +
    +Color(std::string _input);
    +
    +
    + +
    +

    etk::~Color ()

    + +
    +~Color(void);
    +
    +
    + +
    +

    operator= ()

    + +
    +Color & operator=(const etk::Color & _input);
    +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const etk::Color & _obj);
    +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const etk::Color & _obj);
    +
    +
    + +
    +

    get ()

    + +
    +uint32_t get(void);
    +
    +
    + +
    +

    set ()

    + +
    +void set(float _r,
+         float _g,
+         float _b,
+         float _a);
    +
    +
    + +
    +

    set ()

    + +
    +void set(uint8_t _r,
+         uint8_t _g,
+         uint8_t _b,
+         uint8_t _a);
    +
    +
    + +
    +

    set ()

    + +
    +void set(int _r,
+         int _g,
+         int _b,
+         int _a);
    +
    +
    + +
    +

    getHexString ()

    + +
    +std::string getHexString(void);
    +
    +
    + +
    +

    getString ()

    + +
    +std::string getString(void);
    +
    +
    + +
    +

    r ()

    + +
    +MY_TYPE r(void);
    +
    +
    + +
    +

    g ()

    + +
    +MY_TYPE g(void);
    +
    +
    + +
    +

    b ()

    + +
    +MY_TYPE b(void);
    +
    +
    + +
    +

    a ()

    + +
    +MY_TYPE a(void);
    +
    +
    + +
    +

    setR ()

    + +
    +void setR(MY_TYPE _r);
    +
    +
    + +
    +

    setG ()

    + +
    +void setG(MY_TYPE _g);
    +
    +
    + +
    +

    setB ()

    + +
    +void setB(MY_TYPE _b);
    +
    +
    + +
    +

    setA ()

    + +
    +void setA(MY_TYPE _a);
    +
    +
    + +
    +
    + + diff --git a/etk__FSNType.html b/etk__FSNType.html new file mode 100644 index 0000000..e015632 --- /dev/null +++ b/etk__FSNType.html @@ -0,0 +1,76 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Enum: etk::FSNType

    +
    +Value :
    + +
    + + diff --git a/etk__FSNode.html b/etk__FSNode.html new file mode 100644 index 0000000..3a4687d --- /dev/null +++ b/etk__FSNode.html @@ -0,0 +1,788 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::FSNode

    +
    +

    Synopsis:

    +
    ++                              FSNode                   (const std::string & _path);
    +                              FSNode                   (const std::u32string & _path);
    +                             ~FSNode                   (void);
    +  bool                        exist                    (void);
    +  etk::FSNodeRight            getRight                 (void);
    +  bool                        setRight                 (etk::FSNodeRight _newRight);
    +  void                        setName                  (const std::string & _newName);
    +  void                        setName                  (const std::u32string & _newName);
    +  std::string                 getFileSystemName        (void);
    +  std::u32string              getUFileSystemName       (void);
    +  std::string                 getNameFolder            (void);
    +  std::u32string              getUNameFolder           (void);
    +  std::string                 getName                  (void);
    +  std::u32string              getUName                 (void);
    +  std::string                 getNameFile              (void);
    +  std::u32string              getUNameFile             (void);
    +  std::string                 getRelativeFolder        (void);
    +  std::u32string              getURelativeFolder       (void);
    +  bool                        touch                    (void);
    +  bool                        move                     (const std::string & _path);
    +  bool                        move                     (const std::u32string & _path);
    +  bool                        remove                   (void);
    +  uint64_t                    timeCreated              (void);
    +  std::string                 timeCreatedString        (void);
    +  std::u32string              timeUCreatedString       (void);
    +  uint64_t                    timeModified             (void);
    +  std::string                 timeModifiedString       (void);
    +  std::u32string              timeUModifiedString      (void);
    +  uint64_t                    timeAccessed             (void);
    +  std::string                 timeAccessedString       (void);
    +  std::u32string              timeUAccessedString      (void);
    +  const etk::FSNode &         operator=                (const etk::FSNode & _obj);
    +  bool                        operator==               (const etk::FSNode & _obj);
    +  bool                        operator!=               (const etk::FSNode & _obj);
    +  friend etk::CCout &         operator<<               (etk::CCout & _os,
                                                             const etk::FSNode & _obj);
    +  int64_t                     folderCount              (void);
    +  std::vector  folderGetSubList         (bool _showHidenFile,
                                                             bool _getFolderAndOther,
                                                             bool _getFile,
                                                             bool _temporaryFile);
    +  etk::FSNode                 folderGetParent          (void);
    +  void                        folderGetRecursiveFiles  (std::vector & _output,
                                                             bool _recursiveEnable);
    +  void                        folderGetRecursiveFiles  (std::vector & _output,
                                                             bool _recursiveEnable);
    +  bool                        fileHasExtention         (void);
    +  std::string                 fileGetExtention         (void);
    +  std::u32string              fileUGetExtention        (void);
    +  uint64_t                    fileSize                 (void);
    +  bool                        fileOpenRead             (void);
    +  bool                        fileOpenWrite            (void);
    +  bool                        fileOpenAppend           (void);
    +  bool                        fileClose                (void);
    +  char *                      fileGets                 (char * _elementLine,
                                                             int64_t _maxData);
    +  char                        fileGet                  (void);
    +  int64_t                     fileRead                 (void * _data,
                                                             int64_t _blockSize,
                                                             int64_t _nbBlock);
    +  int64_t                     fileWrite                (void * _data,
                                                             int64_t _blockSize,
                                                             int64_t _nbBlock);
    +  bool                        fileSeek                 (long int _offset,
                                                             enum etk::seekNode _origin);
    +  void                        fileFlush                (void);
    -  void                        generateFileSystemPath   (void);
    -  void                        updateFileSystemProperty (void);
    -  void                        privateSetName           (const std::string & _newName);
    -  void                        privateSetName           (const std::u32string & _newName);
    -  bool                        loadDataZip              (void);
    -  void                        sortElementList          (std::vector & _list);
    + + +

    Description:

    +/** +* @brief FS node is for File system IO access This class is independent of the OS, If you acces to a file in windows, it might generate the right loke Linux (it is important to know that windows right is lighter than linux) +*/

    Detail:

    +

    etk::FSNode ()

    + +
    +FSNode(const std::string & _path);
    +
    +Constructor +
    +
    + +
    +

    etk::FSNode ()

    + +
    +FSNode(const std::u32string & _path);
    +
    +
    + +
    +

    etk::~FSNode ()

    + +
    +~FSNode(void);
    +
    +Destructor +
    Notes: you will have some warning if you did not close your files +

    + +
    +

    exist ()

    + +
    +bool exist(void);
    +
    +Check if the node exist. +
    +
    + +
    +

    getRight ()

    + +
    +etk::FSNodeRight getRight(void);
    +
    +Get the node Right +
    +
    + +
    +

    setRight ()

    + +
    +bool setRight(etk::FSNodeRight _newRight);
    +
    +Set the specific right of the node +
    +
    + +
    +

    setName ()

    + +
    +void setName(const std::string & _newName);
    +
    +Change the Node seeing (not rename the node, for this
    +
    + +
    +

    setName ()

    + +
    +void setName(const std::u32string & _newName);
    +
    +
    + +
    +

    getFileSystemName ()

    + +
    +std::string getFileSystemName(void);
    +
    +Get the Generate FileSystem name +
    +
    + +
    +

    getUFileSystemName ()

    + +
    +std::u32string getUFileSystemName(void);
    +
    +
    + +
    +

    getNameFolder ()

    + +
    +std::string getNameFolder(void);
    +
    +Get the current folder of the Node. (file system name) +
    Notes: Auto remove of ../../../ and // +
    +
    + +
    +

    getUNameFolder ()

    + +
    +std::u32string getUNameFolder(void);
    +
    +
    + +
    +

    getName ()

    + +
    +std::string getName(void);
    +
    +Get the current compleate node name (file system name) +
    Notes: Auto remove of ../../../ and // +
    +
    + +
    +

    getUName ()

    + +
    +std::u32string getUName(void);
    +
    +
    + +
    +

    getNameFile ()

    + +
    +std::string getNameFile(void);
    +
    +Get the file or current file name (if it was a file) +
    +
    + +
    +

    getUNameFile ()

    + +
    +std::u32string getUNameFile(void);
    +
    +
    + +
    +

    getRelativeFolder ()

    + +
    +std::string getRelativeFolder(void);
    +
    +Get the current folder of the Node. +
    Notes: Auto remove of ../../../ and // +
    +
    + +
    +

    getURelativeFolder ()

    + +
    +std::u32string getURelativeFolder(void);
    +
    +
    + +
    +

    touch ()

    + +
    +bool touch(void);
    +
    +update the Time of the file with the current time +
    +
    + +
    +

    move ()

    + +
    +bool move(const std::string & _path);
    +
    +Move the Node at a new path +
    +
    + +
    +

    move ()

    + +
    +bool move(const std::u32string & _path);
    +
    +
    + +
    +

    remove ()

    + +
    +bool remove(void);
    +
    +Remove the current node ( if folder, this remove all subfolder but not the Link subfolder) +
    +
    + +
    +

    timeCreated ()

    + +
    +uint64_t timeCreated(void);
    +
    +Get the creating time of the File +
    +
    + +
    +

    timeCreatedString ()

    + +
    +std::string timeCreatedString(void);
    +
    +Get the creating time of the File +
    +
    + +
    +

    timeUCreatedString ()

    + +
    +std::u32string timeUCreatedString(void);
    +
    +
    + +
    +

    timeModified ()

    + +
    +uint64_t timeModified(void);
    +
    +Get the modifying time of the File +
    +
    + +
    +

    timeModifiedString ()

    + +
    +std::string timeModifiedString(void);
    +
    +Get the modifying time of the File +
    +
    + +
    +

    timeUModifiedString ()

    + +
    +std::u32string timeUModifiedString(void);
    +
    +
    + +
    +

    timeAccessed ()

    + +
    +uint64_t timeAccessed(void);
    +
    +Get the Accessed time of the File +
    +
    + +
    +

    timeAccessedString ()

    + +
    +std::string timeAccessedString(void);
    +
    +Get the Accessed time of the File +
    +
    + +
    +

    timeUAccessedString ()

    + +
    +std::u32string timeUAccessedString(void);
    +
    +
    + +
    +

    operator= ()

    + +
    +const etk::FSNode & operator=(const etk::FSNode & _obj);
    +
    +copy the other FSnode ==> for vector +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const etk::FSNode & _obj);
    +
    +Check if the 2 node are link with the same file +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const etk::FSNode & _obj);
    +
    +Check if the 2 node are NOT link with the same file +
    +
    + +
    +

    operator<< ()

    + +
    +friend etk::CCout & operator<<(etk::CCout & _os,
+                               const etk::FSNode & _obj);
    +
    +Write in the statard debug IO the current node +
    +
    + +
    +

    folderCount ()

    + +
    +int64_t folderCount(void);
    +
    +Count the number of subFolder in the curent Folder +
    +
    + +
    +

    folderGetSubList ()

    + +
    +std::vector folderGetSubList(bool _showHidenFile,
+                                            bool _getFolderAndOther,
+                                            bool _getFile,
+                                            bool _temporaryFile);
    +
    +Get the List of all node inside a node (folder only) +
    +
    + +
    +

    folderGetParent ()

    + +
    +etk::FSNode folderGetParent(void);
    +
    +Get the father node of this node +
    +
    + +
    +

    folderGetRecursiveFiles ()

    + +
    +void folderGetRecursiveFiles(std::vector & _output,
+                             bool _recursiveEnable);
    +
    +Get all the File inside a Folder (done recursively) +
    +
    + +
    +

    folderGetRecursiveFiles ()

    + +
    +void folderGetRecursiveFiles(std::vector & _output,
+                             bool _recursiveEnable);
    +
    +
    + +
    +

    fileHasExtention ()

    + +
    +bool fileHasExtention(void);
    +
    +Check if the file have an extention ( ***.ccc) +
    +
    + +
    +

    fileGetExtention ()

    + +
    +std::string fileGetExtention(void);
    +
    +Get the extention of the Node +
    +
    + +
    +

    fileUGetExtention ()

    + +
    +std::u32string fileUGetExtention(void);
    +
    +
    + +
    +

    fileSize ()

    + +
    +uint64_t fileSize(void);
    +
    +Get the File size +
    +
    + +
    +

    fileOpenRead ()

    + +
    +bool fileOpenRead(void);
    +
    +Open the file in Read mode +
    +
    + +
    +

    fileOpenWrite ()

    + +
    +bool fileOpenWrite(void);
    +
    +Open the file in write Mode +
    Notes: You can not do it with the DATA: file ==> this is not allowed in some Board like Android) +
    +
    + +
    +

    fileOpenAppend ()

    + +
    +bool fileOpenAppend(void);
    +
    +Open the file in write Append Mode +
    Notes: You can not do it with the DATA: file ==> this is not allowed in some Board like Android) +
    +
    + +
    +

    fileClose ()

    + +
    +bool fileClose(void);
    +
    +Close the cuurent file +
    +
    + +
    +

    fileGets ()

    + +
    +char * fileGets(char * _elementLine,
+                int64_t _maxData);
    +
    +Get the pointer on the start line and the next line (or null) +
    +
    + +
    +

    fileGet ()

    + +
    +char fileGet(void);
    +
    +Get a unique data in the file +
    +
    + +
    +

    fileRead ()

    + +
    +int64_t fileRead(void * _data,
+                 int64_t _blockSize,
+                 int64_t _nbBlock);
    +
    +Read data from the file +
    +
    + +
    +

    fileWrite ()

    + +
    +int64_t fileWrite(void * _data,
+                  int64_t _blockSize,
+                  int64_t _nbBlock);
    +
    +Write data on the file +
    +
    + +
    +

    fileSeek ()

    + +
    +bool fileSeek(long int _offset,
+              enum etk::seekNode _origin);
    +
    +Move in the file Position +
    +
    + +
    +

    fileFlush ()

    + +
    +void fileFlush(void);
    +
    +Flush the current file +

    + +
    +

    generateFileSystemPath ()

    + +
    +void generateFileSystemPath(void);
    +
    +Internal methode that create the internal Real system name (transform DATA: HOME: DATA:GUI: in the real name of the files) +

    + +
    +

    updateFileSystemProperty ()

    + +
    +void updateFileSystemProperty(void);
    +
    +Update the internal data of the right type, and times +

    + +
    +

    privateSetName ()

    + +
    +void privateSetName(const std::string & _newName);
    +
    +Common set name of the Node (if the user decide to change the node selection +
    +
    + +
    +

    privateSetName ()

    + +
    +void privateSetName(const std::u32string & _newName);
    +
    +
    + +
    +

    loadDataZip ()

    + +
    +bool loadDataZip(void);
    +
    +Explocitly for Android that data are stored in the .apk that is a .zip not compressed +
    +
    + +
    +

    sortElementList ()

    + +
    +void sortElementList(std::vector & _list);
    +
    +Order the list of subnode the folder first and the alphabetical order +
    +
    + +
    +
    + + diff --git a/etk__FSNodeRight.html b/etk__FSNodeRight.html new file mode 100644 index 0000000..27e3f9e --- /dev/null +++ b/etk__FSNodeRight.html @@ -0,0 +1,287 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::FSNodeRight

    +
    +

    Synopsis:

    +
    ++                            FSNodeRight       (void);
    +                            FSNodeRight       (int16_t _newRight);
    +                           ~FSNodeRight       (void);
    +  const etk::FSNodeRight &  operator=         (const etk::FSNodeRight & _obj);
    +  const etk::FSNodeRight &  operator=         (const int32_t _newVal);
    +  void                      clear             (void);
    +  bool                      isUserReadable    (void);
    +  bool                      isUserWritable    (void);
    +  bool                      isUserRunable     (void);
    +  void                      setUserReadable   (bool _newStatus);
    +  void                      setUserWritable   (bool _newStatus);
    +  void                      setUserRunable    (bool _newStatus);
    +  bool                      isGroupReadable   (void);
    +  bool                      isGroupWritable   (void);
    +  bool                      isGroupRunable    (void);
    +  void                      setGroupReadable  (bool _newStatus);
    +  void                      setGroupWritable  (bool _newStatus);
    +  void                      setGroupRunable   (bool _newStatus);
    +  bool                      isOtherReadable   (void);
    +  bool                      isOtherWritable   (void);
    +  bool                      isOtherRunable    (void);
    +  void                      setOtherReadable  (bool _newStatus);
    +  void                      setOtherWritable  (bool _newStatus);
    +  void                      setOtherRunable   (bool _newStatus);
    +  std::u32string            getURight         (void);
    +  std::string               getRight          (void);
    + + +

    Detail:

    +

    etk::FSNodeRight ()

    + +
    +FSNodeRight(void);
    +
    +
    + +
    +

    etk::FSNodeRight ()

    + +
    +FSNodeRight(int16_t _newRight);
    +
    +
    + +
    +

    etk::~FSNodeRight ()

    + +
    +~FSNodeRight(void);
    +
    +
    + +
    +

    operator= ()

    + +
    +const etk::FSNodeRight & operator=(const etk::FSNodeRight & _obj);
    +
    +
    + +
    +

    operator= ()

    + +
    +const etk::FSNodeRight & operator=(const int32_t _newVal);
    +
    +
    + +
    +

    clear ()

    + +
    +void clear(void);
    +
    +
    + +
    +

    isUserReadable ()

    + +
    +bool isUserReadable(void);
    +
    +
    + +
    +

    isUserWritable ()

    + +
    +bool isUserWritable(void);
    +
    +
    + +
    +

    isUserRunable ()

    + +
    +bool isUserRunable(void);
    +
    +
    + +
    +

    setUserReadable ()

    + +
    +void setUserReadable(bool _newStatus);
    +
    +
    + +
    +

    setUserWritable ()

    + +
    +void setUserWritable(bool _newStatus);
    +
    +
    + +
    +

    setUserRunable ()

    + +
    +void setUserRunable(bool _newStatus);
    +
    +
    + +
    +

    isGroupReadable ()

    + +
    +bool isGroupReadable(void);
    +
    +
    + +
    +

    isGroupWritable ()

    + +
    +bool isGroupWritable(void);
    +
    +
    + +
    +

    isGroupRunable ()

    + +
    +bool isGroupRunable(void);
    +
    +
    + +
    +

    setGroupReadable ()

    + +
    +void setGroupReadable(bool _newStatus);
    +
    +
    + +
    +

    setGroupWritable ()

    + +
    +void setGroupWritable(bool _newStatus);
    +
    +
    + +
    +

    setGroupRunable ()

    + +
    +void setGroupRunable(bool _newStatus);
    +
    +
    + +
    +

    isOtherReadable ()

    + +
    +bool isOtherReadable(void);
    +
    +
    + +
    +

    isOtherWritable ()

    + +
    +bool isOtherWritable(void);
    +
    +
    + +
    +

    isOtherRunable ()

    + +
    +bool isOtherRunable(void);
    +
    +
    + +
    +

    setOtherReadable ()

    + +
    +void setOtherReadable(bool _newStatus);
    +
    +
    + +
    +

    setOtherWritable ()

    + +
    +void setOtherWritable(bool _newStatus);
    +
    +
    + +
    +

    setOtherRunable ()

    + +
    +void setOtherRunable(bool _newStatus);
    +
    +
    + +
    +

    getURight ()

    + +
    +std::u32string getURight(void);
    +
    +
    + +
    +

    getRight ()

    + +
    +std::string getRight(void);
    +
    +
    + +
    +
    + + diff --git a/etk__Hash.html b/etk__Hash.html new file mode 100644 index 0000000..f58a795 --- /dev/null +++ b/etk__Hash.html @@ -0,0 +1,242 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Hash

    +
    +

    Synopsis:

    +
    ++                       Hash        (int32_t _count);
    +                      ~Hash        (void);
    +  void                 clear       (void);
    +  int64_t              getId       (const std::string & _key);
    +  bool                 exist       (const std::string & _name);
    +  MY_TYPE &            get         (const std::string & _key);
    +  MY_TYPE &            operator[]  (const std::string & _key);
    +  const MY_TYPE &      operator[]  (const std::string & _key);
    +  void                 add         (const std::string & _key,
                                         const MY_TYPE & _value);
    +  void                 set         (const std::string & _key,
                                         const MY_TYPE & _value);
    +  void                 remove      (const std::string & _key);
    +  int32_t              size        (void);
    +  MY_TYPE &            operator[]  (size_t _pos);
    +  const MY_TYPE &      operator[]  (size_t _pos);
    +  const std::string &  getKey      (size_t _pos);
    +  const MY_TYPE &      getValue    (size_t _pos);
    +  MY_TYPE &            getValue    (size_t _pos);
    + + +

    Detail:

    +

    etk::Hash ()

    + +
    +Hash(int32_t _count);
    +
    +
    + +
    +

    etk::~Hash ()

    + +
    +~Hash(void);
    +
    +
    + +
    +

    clear ()

    + +
    +void clear(void);
    +
    +Remove all entry in the Hash table +

    + +
    +

    getId ()

    + +
    +int64_t getId(const std::string & _key);
    +
    +Get a current element ID in the Hash table +
    +
    + +
    +

    exist ()

    + +
    +bool exist(const std::string & _name);
    +
    +Check if an element exist or not +
    +
    + +
    +

    get ()

    + +
    +MY_TYPE & get(const std::string & _key);
    +
    +Get a current element in the vector +
    +
    + +
    +

    operator[] ()

    + +
    +MY_TYPE & operator[](const std::string & _key);
    +
    +Get an copy Element an a special position +
    +
    + +
    +

    operator[] ()

    + +
    +const MY_TYPE & operator[](const std::string & _key);
    +
    +
    + +
    +

    add ()

    + +
    +void add(const std::string & _key,
+         const MY_TYPE & _value);
    +
    +
    + +
    +

    set ()

    + +
    +void set(const std::string & _key,
+         const MY_TYPE & _value);
    +
    +
    + +
    +

    remove ()

    + +
    +void remove(const std::string & _key);
    +
    +
    + +
    +

    size ()

    + +
    +int32_t size(void);
    +
    +Get the number of element in the hash table +
    +
    + +
    +

    operator[] ()

    + +
    +MY_TYPE & operator[](size_t _pos);
    +
    +
    + +
    +

    operator[] ()

    + +
    +const MY_TYPE & operator[](size_t _pos);
    +
    +
    + +
    +

    getKey ()

    + +
    +const std::string & getKey(size_t _pos);
    +
    +
    + +
    +

    getValue ()

    + +
    +const MY_TYPE & getValue(size_t _pos);
    +
    +
    + +
    +

    getValue ()

    + +
    +MY_TYPE & getValue(size_t _pos);
    +
    +
    + +
    +
    + + diff --git a/etk__HashData.html b/etk__HashData.html new file mode 100644 index 0000000..1626d59 --- /dev/null +++ b/etk__HashData.html @@ -0,0 +1,88 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::HashData

    +
    +

    Synopsis:

    +
    ++        HashData  (const std::string & _key,
                        const MY_TYPE & _val);
    + + +

    Detail:

    +

    etk::HashData ()

    + +
    +HashData(const std::string & _key,
+         const MY_TYPE & _val);
    +
    +
    + +
    +
    + + diff --git a/etk__Matrix4.html b/etk__Matrix4.html new file mode 100644 index 0000000..6c15ad0 --- /dev/null +++ b/etk__Matrix4.html @@ -0,0 +1,314 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Matrix4

    +
    +

    Synopsis:

    +
    ++  void             identity    (void);
    +                   Matrix4     (void);
    +                   Matrix4     (const Matrix4 & obj);
    +                   Matrix4     (float a1,
                                     float b1,
                                     float c1,
                                     float d1,
                                     float a2,
                                     float b2,
                                     float c2,
                                     float d2,
                                     float a3,
                                     float b3,
                                     float c3,
                                     float d3,
                                     float a4,
                                     float b4,
                                     float c4,
                                     float d4);
    +                   Matrix4     (float * obj);
    +                  ~Matrix4     (void);
    +  const Matrix4 &  operator=   (const Matrix4 & obj);
    +  bool             operator==  (const Matrix4 & obj);
    +  bool             operator!=  (const Matrix4 & obj);
    +  const Matrix4 &  operator+=  (const Matrix4 & obj);
    +  Matrix4          operator+   (const Matrix4 & obj);
    +  const Matrix4 &  operator-=  (const Matrix4 & obj);
    +  Matrix4          operator-   (const Matrix4 & obj);
    +  const Matrix4 &  operator*=  (const Matrix4 & obj);
    +  Matrix4          operator*   (const Matrix4 & obj);
    +  vec3             operator*   (const vec3 & point);
    +  void             transpose   (void);
    +  void             scale       (const vec3 & p);
    +  void             scale       (float sx,
                                     float sy,
                                     float sz);
    +  void             rotate      (const vec3 & vect,
                                     float angleRad);
    +  void             translate   (const vec3 & vect);
    +  float            coFactor    (int32_t row,
                                     int32_t col);
    +  float            determinant (void);
    +  Matrix4          invert      (void);
    + + +

    Detail:

    +

    identity ()

    + +
    +void identity(void);
    +
    +
    + +
    +

    etk::Matrix4 ()

    + +
    +Matrix4(void);
    +
    +
    + +
    +

    etk::Matrix4 ()

    + +
    +Matrix4(const Matrix4 & obj);
    +
    +
    + +
    +

    etk::Matrix4 ()

    + +
    +Matrix4(float a1,
+        float b1,
+        float c1,
+        float d1,
+        float a2,
+        float b2,
+        float c2,
+        float d2,
+        float a3,
+        float b3,
+        float c3,
+        float d3,
+        float a4,
+        float b4,
+        float c4,
+        float d4);
    +
    +
    + +
    +

    etk::Matrix4 ()

    + +
    +Matrix4(float * obj);
    +
    +
    + +
    +

    etk::~Matrix4 ()

    + +
    +~Matrix4(void);
    +
    +
    + +
    +

    operator= ()

    + +
    +const Matrix4 & operator=(const Matrix4 & obj);
    +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const Matrix4 & obj);
    +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const Matrix4 & obj);
    +
    +
    + +
    +

    operator+= ()

    + +
    +const Matrix4 & operator+=(const Matrix4 & obj);
    +
    +
    + +
    +

    operator+ ()

    + +
    +Matrix4 operator+(const Matrix4 & obj);
    +
    +
    + +
    +

    operator-= ()

    + +
    +const Matrix4 & operator-=(const Matrix4 & obj);
    +
    +
    + +
    +

    operator- ()

    + +
    +Matrix4 operator-(const Matrix4 & obj);
    +
    +
    + +
    +

    operator*= ()

    + +
    +const Matrix4 & operator*=(const Matrix4 & obj);
    +
    +
    + +
    +

    operator* ()

    + +
    +Matrix4 operator*(const Matrix4 & obj);
    +
    +
    + +
    +

    operator* ()

    + +
    +vec3 operator*(const vec3 & point);
    +
    +
    + +
    +

    transpose ()

    + +
    +void transpose(void);
    +
    +
    + +
    +

    scale ()

    + +
    +void scale(const vec3 & p);
    +
    +
    + +
    +

    scale ()

    + +
    +void scale(float sx,
+           float sy,
+           float sz);
    +
    +
    + +
    +

    rotate ()

    + +
    +void rotate(const vec3 & vect,
+            float angleRad);
    +
    +Makes a rotation matrix about an arbitrary axis. +
    +
    + +
    +

    translate ()

    + +
    +void translate(const vec3 & vect);
    +
    +Makes a translation of the matrix +
    +
    + +
    +

    coFactor ()

    + +
    +float coFactor(int32_t row,
+               int32_t col);
    +
    +Computes a cofactor. Used for matrix inversion. +
    +
    + +
    +

    determinant ()

    + +
    +float determinant(void);
    +
    +Computes the determinant of the matrix. +
    +
    + +
    +

    invert ()

    + +
    +Matrix4 invert(void);
    +
    +Inverts the matrix. +
    Notes: The determinant must be != 0, otherwithe the matrix can't be inverted. +
    +
    + +
    +
    + + diff --git a/etk__MessageFifo.html b/etk__MessageFifo.html new file mode 100644 index 0000000..a2e98bb --- /dev/null +++ b/etk__MessageFifo.html @@ -0,0 +1,136 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::MessageFifo

    +
    +

    Synopsis:

    +
    ++           MessageFifo  (void);
    +          ~MessageFifo  (void);
    +  bool     wait         (MY_TYPE & _data);
    +  bool     wait         (MY_TYPE & _data,
                              uint32_t _timeOutInUs);
    +  int32_t  count        (void);
    +  void     post         (MY_TYPE & _data);
    +  void     clean        (void);
    + + +

    Detail:

    +

    etk::MessageFifo ()

    + +
    +MessageFifo(void);
    +
    +
    + +
    +

    etk::~MessageFifo ()

    + +
    +~MessageFifo(void);
    +
    +
    + +
    +

    wait ()

    + +
    +bool wait(MY_TYPE & _data);
    +
    +
    + +
    +

    wait ()

    + +
    +bool wait(MY_TYPE & _data,
+          uint32_t _timeOutInUs);
    +
    +
    + +
    +

    count ()

    + +
    +int32_t count(void);
    +
    +
    + +
    +

    post ()

    + +
    +void post(MY_TYPE & _data);
    +
    +
    + +
    +

    clean ()

    + +
    +void clean(void);
    +
    +
    + +
    +
    + + diff --git a/etk__Mutex.html b/etk__Mutex.html new file mode 100644 index 0000000..a7d9bb1 --- /dev/null +++ b/etk__Mutex.html @@ -0,0 +1,119 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Mutex

    +
    +

    Synopsis:

    +
    ++        Mutex    (void);
    +       ~Mutex    (void);
    +  void  lock     (void);
    +  bool  tryLock  (void);
    +  void  unLock   (void);
    + + +

    Detail:

    +

    etk::Mutex ()

    + +
    +Mutex(void);
    +
    +
    + +
    +

    etk::~Mutex ()

    + +
    +~Mutex(void);
    +
    +
    + +
    +

    lock ()

    + +
    +void lock(void);
    +
    +
    + +
    +

    tryLock ()

    + +
    +bool tryLock(void);
    +
    +
    + +
    +

    unLock ()

    + +
    +void unLock(void);
    +
    +
    + +
    +
    + + diff --git a/etk__Noise.html b/etk__Noise.html new file mode 100644 index 0000000..3f7bf02 --- /dev/null +++ b/etk__Noise.html @@ -0,0 +1,138 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Noise

    +
    +

    Synopsis:

    +
    ++        Noise               (enum noise _type,
                                  ivec2 _size,
                                  int32_t _depth);
    +       ~Noise               (void);
    +  float get                 (int32_t _x,
                                  int32_t _y);
    -  float smoothNoise         (float _x,
                                  float _y,
                                  const etk::BaseNoise & _noise);
    -  float turbulence          (float _x,
                                  float _y,
                                  float _size,
                                  const etk::BaseNoise & _noise);
    -  float turbulenceNoSmooth  (float _x,
                                  float _y,
                                  float _size,
                                  const etk::BaseNoise & _noise);
    + + +

    Detail:

    +

    etk::Noise ()

    + +
    +Noise(enum noise _type,
+      ivec2 _size,
+      int32_t _depth);
    +
    +
    + +
    +

    etk::~Noise ()

    + +
    +~Noise(void);
    +
    +
    + +
    +

    get ()

    + +
    +float get(int32_t _x,
+          int32_t _y);
    +
    +
    + +
    +

    smoothNoise ()

    + +
    +float smoothNoise(float _x,
+                  float _y,
+                  const etk::BaseNoise & _noise);
    +
    +
    + +
    +

    turbulence ()

    + +
    +float turbulence(float _x,
+                 float _y,
+                 float _size,
+                 const etk::BaseNoise & _noise);
    +
    +
    + +
    +

    turbulenceNoSmooth ()

    + +
    +float turbulenceNoSmooth(float _x,
+                         float _y,
+                         float _size,
+                         const etk::BaseNoise & _noise);
    +
    +
    + +
    +
    + + diff --git a/etk__Plane.html b/etk__Plane.html new file mode 100644 index 0000000..9747007 --- /dev/null +++ b/etk__Plane.html @@ -0,0 +1,229 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Plane

    +
    +

    Synopsis:

    +
    ++                    Plane               (void);
    +                    Plane               (etk::Vector3D _normal,
                                              T _intercept);
    +                    Plane               (const Plane & obj);
    +                   ~Plane               (void);
    +  void              setNormal           (const etk::Vector3D & _obj);
    +  void              setIntercept        (float _intercept);
    +  void              setFromPoints       (const etk::Vector3D & p0,
                                              const etk::Vector3D & p1,
                                              const etk::Vector3D & p2);
    +  void              calculateIntercept  (const etk::Vector3D & _pointOnPlane);
    +  void              normalize           (void);
    +  etk::Vector3D  getNormal           (void);
    +  float             getIntercept        (void);
    +  bool              intersect3          (const Plane & _p2,
                                              const Plane & _p3,
                                              etk::Vector3D & _result);
    +  float             getDistance         (const etk::Vector3D & _point);
    +  Plane          linearInterpolate   (const Plane & _p2,
                                              float _factor);
    +  bool              operator==          (const Plane & _obj);
    +  bool              operator!=          (const Plane & _obj);
    +  Plane          operator-           (void);
    +  Plane          operator+           (void);
    + + +

    Detail:

    +

    etk::Plane ()

    + +
    +Plane(void);
    +
    +
    + +
    +

    etk::Plane ()

    + +
    +Plane(etk::Vector3D _normal,
+      T _intercept);
    +
    +
    + +
    +

    etk::Plane ()

    + +
    +Plane(const Plane & obj);
    +
    +
    + +
    +

    etk::~Plane ()

    + +
    +~Plane(void);
    +
    +
    + +
    +

    setNormal ()

    + +
    +void setNormal(const etk::Vector3D & _obj);
    +
    +
    + +
    +

    setIntercept ()

    + +
    +void setIntercept(float _intercept);
    +
    +
    + +
    +

    setFromPoints ()

    + +
    +void setFromPoints(const etk::Vector3D & p0,
+                   const etk::Vector3D & p1,
+                   const etk::Vector3D & p2);
    +
    +
    + +
    +

    calculateIntercept ()

    + +
    +void calculateIntercept(const etk::Vector3D & _pointOnPlane);
    +
    +
    + +
    +

    normalize ()

    + +
    +void normalize(void);
    +
    +
    + +
    +

    getNormal ()

    + +
    +etk::Vector3D getNormal(void);
    +
    +
    + +
    +

    getIntercept ()

    + +
    +float getIntercept(void);
    +
    +
    + +
    +

    intersect3 ()

    + +
    +bool intersect3(const Plane & _p2,
+                const Plane & _p3,
+                etk::Vector3D & _result);
    +
    +
    + +
    +

    getDistance ()

    + +
    +float getDistance(const etk::Vector3D & _point);
    +
    +
    + +
    +

    linearInterpolate ()

    + +
    +Plane linearInterpolate(const Plane & _p2,
+                           float _factor);
    +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const Plane & _obj);
    +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const Plane & _obj);
    +
    +
    + +
    +

    operator- ()

    + +
    +Plane operator-(void);
    +
    +
    + +
    +

    operator+ ()

    + +
    +Plane operator+(void);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExp.html b/etk__RegExp.html new file mode 100644 index 0000000..a4911b1 --- /dev/null +++ b/etk__RegExp.html @@ -0,0 +1,256 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExp

    +
    +

    Synopsis:

    +
    ++                          RegExp             (const std::u32string & _exp);
    +                          RegExp             (const std::string & _exp);
    +                         ~RegExp             (void);
    +  void                    setRegExp          (const std::string & _exp);
    +  void                    setRegExp          (const std::u32string & _regexp);
    +  std::string             getRegExp          (void);
    +  const std::u32string &  getURegExp         (void);
    +  bool                    getStatus          (void);
    +  bool                    process            (const CLASS_TYPE & _SearchIn,
                                                   int64_t _startPos,
                                                   int64_t _endPos,
                                                   char32_t _escapeChar);
    +  bool                    processOneElement  (const CLASS_TYPE & _SearchIn,
                                                   int64_t _startPos,
                                                   int64_t _endPos,
                                                   char32_t _escapeChar);
    +  int64_t                 start              (void);
    +  int64_t                 stop               (void);
    +  void                    display            (void);
    +  void                    drawColoredRegEx   (void);
    -  bool                    checkGoodPosition  (const std::vector<char32_t> & _tmpExp,
                                                   int64_t & _pos);
    -  bool                    checkGoodPosition  (const std::vector<char32_t> & _tmpExp);
    + + +

    Detail:

    +

    etk::RegExp ()

    + +
    +RegExp(const std::u32string & _exp);
    +
    +Constructor +
    +
    + +
    +

    etk::RegExp ()

    + +
    +RegExp(const std::string & _exp);
    +
    +
    + +
    +

    etk::~RegExp ()

    + +
    +~RegExp(void);
    +
    +Destructor +

    + +
    +

    setRegExp ()

    + +
    +void setRegExp(const std::string & _exp);
    +
    +Set a new regular expression matching +
    +
    + +
    +

    setRegExp ()

    + +
    +void setRegExp(const std::u32string & _regexp);
    +
    +
    + +
    +

    getRegExp ()

    + +
    +std::string getRegExp(void);
    +
    +Get the regular expression string +
    +
    + +
    +

    getURegExp ()

    + +
    +const std::u32string & getURegExp(void);
    +
    +
    + +
    +

    getStatus ()

    + +
    +bool getStatus(void);
    +
    +Get the status if the regular expression parsing +
    +
    + +
    +

    process ()

    + +
    +bool process(const CLASS_TYPE & _SearchIn,
+             int64_t _startPos,
+             int64_t _endPos,
+             char32_t _escapeChar);
    +
    +process the seach of the regular expression in a defined class type +
    +
    + +
    +

    processOneElement ()

    + +
    +bool processOneElement(const CLASS_TYPE & _SearchIn,
+                       int64_t _startPos,
+                       int64_t _endPos,
+                       char32_t _escapeChar);
    +
    +
    + +
    +

    start ()

    + +
    +int64_t start(void);
    +
    +Get the expression start position detected +
    +
    + +
    +

    stop ()

    + +
    +int64_t stop(void);
    +
    +Get the expression stop position detected +
    +
    + +
    +

    display ()

    + +
    +void display(void);
    +
    +Display the reg Exp +

    + +
    +

    drawColoredRegEx ()

    + +
    +void drawColoredRegEx(void);
    +
    +Just display the regExp in color ... +

    + +
    +

    checkGoodPosition ()

    + +
    +bool checkGoodPosition(const std::vector<char32_t> & _tmpExp,
+                       int64_t & _pos);
    +
    + +
    + +
    +

    checkGoodPosition ()

    + +
    +bool checkGoodPosition(const std::vector<char32_t> & _tmpExp);
    +
    + +
    + +
    +
    + + diff --git a/etk__RegExpNode.html b/etk__RegExpNode.html new file mode 100644 index 0000000..73c9f45 --- /dev/null +++ b/etk__RegExpNode.html @@ -0,0 +1,183 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNode

    +
    +

    Synopsis:

    +
    ++           RegExpNode  (void);
    +          ~RegExpNode  (void);
    +  int32_t  generate    (const std::vector<char32_t> & _data);
    +  bool     parse       (const CLASS_TYPE & _data,
                             int64_t _currentPos,
                             int64_t _lenMax,
                             int64_t & _findLen);
    +  void     display     (uint32_t _level);
    +  void     setMult     (uint32_t _min,
                             uint32_t _max);
    #  uint32_t getMultMin  (void);
    #  uint32_t getMultMax  (void);
    + + +

    Description:

    +/** +* @brief Node Elements for every-one +*/

    Detail:

    +

    etk::RegExpNode ()

    + +
    +RegExpNode(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNode ()

    + +
    +~RegExpNode(void);
    +
    +Destructor +

    + +
    +

    generate ()

    + +
    +int32_t generate(const std::vector<char32_t> & _data);
    +
    +Generate the regular expression with the current "converted string" +
    +
    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +Parse the current node +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +Display the current node properties +
    +
    + +
    +

    setMult ()

    + +
    +void setMult(uint32_t _min,
+             uint32_t _max);
    +
    +Set the multiplicity of this Node. +
    +
    + +
    +

    getMultMin ()

    + +
    +uint32_t getMultMin(void);
    +
    +Get the minimum multiplicity. +
    +
    + +
    +

    getMultMax ()

    + +
    +uint32_t getMultMax(void);
    +
    +Get the maximum multiplicity. +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeBracket.html b/etk__RegExpNodeBracket.html new file mode 100644 index 0000000..19d1ef7 --- /dev/null +++ b/etk__RegExpNodeBracket.html @@ -0,0 +1,130 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeBracket

    +
    +

    Synopsis:

    +
    ++           RegExpNodeBracket  (void);
    +          ~RegExpNodeBracket  (void);
    +  int32_t  generate           (const std::vector<char32_t> & _data);
    +  bool     parse              (const CLASS_TYPE & _data,
                                    int64_t _currentPos,
                                    int64_t _lenMax,
                                    int64_t & _findLen);
    +  void     display            (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeBracket
+
    +
    +

    Detail:

    +

    etk::RegExpNodeBracket ()

    + +
    +RegExpNodeBracket(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeBracket ()

    + +
    +~RegExpNodeBracket(void);
    +
    +Destructor +

    + +
    +

    generate ()

    + +
    +int32_t generate(const std::vector<char32_t> & _data);
    +
    +
    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeDigit.html b/etk__RegExpNodeDigit.html new file mode 100644 index 0000000..6d67216 --- /dev/null +++ b/etk__RegExpNodeDigit.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeDigit

    +
    +

    Synopsis:

    +
    ++        RegExpNodeDigit  (void);
    +       ~RegExpNodeDigit  (void);
    +  bool  parse            (const CLASS_TYPE & _data,
                               int64_t _currentPos,
                               int64_t _lenMax,
                               int64_t & _findLen);
    +  void  display          (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeDigit
+
    +
    +

    Detail:

    +

    etk::RegExpNodeDigit ()

    + +
    +RegExpNodeDigit(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeDigit ()

    + +
    +~RegExpNodeDigit(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeDigitNot.html b/etk__RegExpNodeDigitNot.html new file mode 100644 index 0000000..16cdc24 --- /dev/null +++ b/etk__RegExpNodeDigitNot.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeDigitNot

    +
    +

    Synopsis:

    +
    ++        RegExpNodeDigitNot  (void);
    +       ~RegExpNodeDigitNot  (void);
    +  bool  parse               (const CLASS_TYPE & _data,
                                  int64_t _currentPos,
                                  int64_t _lenMax,
                                  int64_t & _findLen);
    +  void  display             (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeDigitNot
+
    +
    +

    Detail:

    +

    etk::RegExpNodeDigitNot ()

    + +
    +RegExpNodeDigitNot(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeDigitNot ()

    + +
    +~RegExpNodeDigitNot(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeDot.html b/etk__RegExpNodeDot.html new file mode 100644 index 0000000..bb4f299 --- /dev/null +++ b/etk__RegExpNodeDot.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeDot

    +
    +

    Synopsis:

    +
    ++        RegExpNodeDot  (void);
    +       ~RegExpNodeDot  (void);
    +  bool  parse          (const CLASS_TYPE & _data,
                             int64_t _currentPos,
                             int64_t _lenMax,
                             int64_t & _findLen);
    +  void  display        (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeDot
+
    +
    +

    Detail:

    +

    etk::RegExpNodeDot ()

    + +
    +RegExpNodeDot(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeDot ()

    + +
    +~RegExpNodeDot(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeEOL.html b/etk__RegExpNodeEOL.html new file mode 100644 index 0000000..cf054c3 --- /dev/null +++ b/etk__RegExpNodeEOL.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeEOL

    +
    +

    Synopsis:

    +
    ++        RegExpNodeEOL  (void);
    +       ~RegExpNodeEOL  (void);
    +  bool  parse          (const CLASS_TYPE & _data,
                             int64_t _currentPos,
                             int64_t _lenMax,
                             int64_t & _findLen);
    +  void  display        (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeEOL
+
    +
    +

    Detail:

    +

    etk::RegExpNodeEOL ()

    + +
    +RegExpNodeEOL(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeEOL ()

    + +
    +~RegExpNodeEOL(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeLetter.html b/etk__RegExpNodeLetter.html new file mode 100644 index 0000000..3a71460 --- /dev/null +++ b/etk__RegExpNodeLetter.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeLetter

    +
    +

    Synopsis:

    +
    ++        RegExpNodeLetter  (void);
    +       ~RegExpNodeLetter  (void);
    +  bool  parse             (const CLASS_TYPE & _data,
                                int64_t _currentPos,
                                int64_t _lenMax,
                                int64_t & _findLen);
    +  void  display           (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeLetter
+
    +
    +

    Detail:

    +

    etk::RegExpNodeLetter ()

    + +
    +RegExpNodeLetter(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeLetter ()

    + +
    +~RegExpNodeLetter(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeLetterNot.html b/etk__RegExpNodeLetterNot.html new file mode 100644 index 0000000..a42992c --- /dev/null +++ b/etk__RegExpNodeLetterNot.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeLetterNot

    +
    +

    Synopsis:

    +
    ++        RegExpNodeLetterNot  (void);
    +       ~RegExpNodeLetterNot  (void);
    +  bool  parse                (const CLASS_TYPE & _data,
                                   int64_t _currentPos,
                                   int64_t _lenMax,
                                   int64_t & _findLen);
    +  void  display              (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeLetterNot
+
    +
    +

    Detail:

    +

    etk::RegExpNodeLetterNot ()

    + +
    +RegExpNodeLetterNot(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeLetterNot ()

    + +
    +~RegExpNodeLetterNot(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodePThese.html b/etk__RegExpNodePThese.html new file mode 100644 index 0000000..9fd299f --- /dev/null +++ b/etk__RegExpNodePThese.html @@ -0,0 +1,139 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodePThese

    +
    +

    Synopsis:

    +
    ++           RegExpNodePThese  (void);
    +          ~RegExpNodePThese  (void);
    +  int32_t  generate          (const std::vector<char32_t> & _data);
    +  bool     parse             (const CLASS_TYPE & _data,
                                   int64_t _currentPos,
                                   int64_t _lenMax,
                                   int64_t & _findLen);
    +  void     display           (uint32_t _level);
    +  void     drawColoredRegEx  (void);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodePThese
+
    +
    +

    Detail:

    +

    etk::RegExpNodePThese ()

    + +
    +RegExpNodePThese(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodePThese ()

    + +
    +~RegExpNodePThese(void);
    +
    +Destructor +

    + +
    +

    generate ()

    + +
    +int32_t generate(const std::vector<char32_t> & _data);
    +
    +
    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +

    drawColoredRegEx ()

    + +
    +void drawColoredRegEx(void);
    +
    +Just display the regExp in color ... +

    + +
    +
    + + diff --git a/etk__RegExpNodePTheseElem.html b/etk__RegExpNodePTheseElem.html new file mode 100644 index 0000000..9ef8a7f --- /dev/null +++ b/etk__RegExpNodePTheseElem.html @@ -0,0 +1,145 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodePTheseElem

    +
    +

    Synopsis:

    +
    ++           RegExpNodePTheseElem       (void);
    +          ~RegExpNodePTheseElem       (void);
    +  int32_t  generate                   (const std::vector<char32_t> & _data);
    +  bool     parse                      (const CLASS_TYPE & _data,
                                            int64_t _currentPos,
                                            int64_t _lenMax,
                                            int64_t & _findLen);
    +  void     display                    (uint32_t _level);
    -  bool     setMultiplicityOnLastNode  (uint32_t _min,
                                            uint32_t _max);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodePTheseElem
+
    +
    +

    Detail:

    +

    etk::RegExpNodePTheseElem ()

    + +
    +RegExpNodePTheseElem(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodePTheseElem ()

    + +
    +~RegExpNodePTheseElem(void);
    +
    +Destructor +

    + +
    +

    generate ()

    + +
    +int32_t generate(const std::vector<char32_t> & _data);
    +
    +
    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +

    setMultiplicityOnLastNode ()

    + +
    +bool setMultiplicityOnLastNode(uint32_t _min,
+                               uint32_t _max);
    +
    +Set the number of repeate time on a the last node in the list ... +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeSOL.html b/etk__RegExpNodeSOL.html new file mode 100644 index 0000000..f7bca78 --- /dev/null +++ b/etk__RegExpNodeSOL.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeSOL

    +
    +

    Synopsis:

    +
    ++        RegExpNodeSOL  (void);
    +       ~RegExpNodeSOL  (void);
    +  bool  parse          (const CLASS_TYPE & _data,
                             int64_t _currentPos,
                             int64_t _lenMax,
                             int64_t & _findLen);
    +  void  display        (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeSOL
+
    +
    +

    Detail:

    +

    etk::RegExpNodeSOL ()

    + +
    +RegExpNodeSOL(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeSOL ()

    + +
    +~RegExpNodeSOL(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeValue.html b/etk__RegExpNodeValue.html new file mode 100644 index 0000000..86ecc1f --- /dev/null +++ b/etk__RegExpNodeValue.html @@ -0,0 +1,130 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeValue

    +
    +

    Synopsis:

    +
    ++           RegExpNodeValue  (void);
    +          ~RegExpNodeValue  (void);
    +  int32_t  generate         (const std::vector<char32_t> & _data);
    +  bool     parse            (const CLASS_TYPE & _data,
                                  int64_t _currentPos,
                                  int64_t _lenMax,
                                  int64_t & _findLen);
    +  void     display          (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeValue
+
    +
    +

    Detail:

    +

    etk::RegExpNodeValue ()

    + +
    +RegExpNodeValue(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeValue ()

    + +
    +~RegExpNodeValue(void);
    +
    +Destructor +

    + +
    +

    generate ()

    + +
    +int32_t generate(const std::vector<char32_t> & _data);
    +
    +
    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeWhiteSpace.html b/etk__RegExpNodeWhiteSpace.html new file mode 100644 index 0000000..31e43e5 --- /dev/null +++ b/etk__RegExpNodeWhiteSpace.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeWhiteSpace

    +
    +

    Synopsis:

    +
    ++        RegExpNodeWhiteSpace  (void);
    +       ~RegExpNodeWhiteSpace  (void);
    +  bool  parse                 (const CLASS_TYPE & _data,
                                    int64_t _currentPos,
                                    int64_t _lenMax,
                                    int64_t & _findLen);
    +  void  display               (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeWhiteSpace
+
    +
    +

    Detail:

    +

    etk::RegExpNodeWhiteSpace ()

    + +
    +RegExpNodeWhiteSpace(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeWhiteSpace ()

    + +
    +~RegExpNodeWhiteSpace(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeWhiteSpaceNot.html b/etk__RegExpNodeWhiteSpaceNot.html new file mode 100644 index 0000000..2fd4667 --- /dev/null +++ b/etk__RegExpNodeWhiteSpaceNot.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeWhiteSpaceNot

    +
    +

    Synopsis:

    +
    ++        RegExpNodeWhiteSpaceNot  (void);
    +       ~RegExpNodeWhiteSpaceNot  (void);
    +  bool  parse                    (const CLASS_TYPE & _data,
                                       int64_t _currentPos,
                                       int64_t _lenMax,
                                       int64_t & _findLen);
    +  void  display                  (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeWhiteSpaceNot
+
    +
    +

    Detail:

    +

    etk::RegExpNodeWhiteSpaceNot ()

    + +
    +RegExpNodeWhiteSpaceNot(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeWhiteSpaceNot ()

    + +
    +~RegExpNodeWhiteSpaceNot(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeWordChar.html b/etk__RegExpNodeWordChar.html new file mode 100644 index 0000000..87be607 --- /dev/null +++ b/etk__RegExpNodeWordChar.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeWordChar

    +
    +

    Synopsis:

    +
    ++        RegExpNodeWordChar  (void);
    +       ~RegExpNodeWordChar  (void);
    +  bool  parse               (const CLASS_TYPE & _data,
                                  int64_t _currentPos,
                                  int64_t _lenMax,
                                  int64_t & _findLen);
    +  void  display             (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeWordChar
+
    +
    +

    Detail:

    +

    etk::RegExpNodeWordChar ()

    + +
    +RegExpNodeWordChar(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeWordChar ()

    + +
    +~RegExpNodeWordChar(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__RegExpNodeWordCharNot.html b/etk__RegExpNodeWordCharNot.html new file mode 100644 index 0000000..bdc7b46 --- /dev/null +++ b/etk__RegExpNodeWordCharNot.html @@ -0,0 +1,122 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::RegExpNodeWordCharNot

    +
    +

    Synopsis:

    +
    ++        RegExpNodeWordCharNot  (void);
    +       ~RegExpNodeWordCharNot  (void);
    +  bool  parse                  (const CLASS_TYPE & _data,
                                     int64_t _currentPos,
                                     int64_t _lenMax,
                                     int64_t & _findLen);
    +  void  display                (uint32_t _level);
    + + +

    Object Hierarchy:

    +
    +RegExpNode
+    +--> etk::RegExpNodeWordCharNot
+
    +
    +

    Detail:

    +

    etk::RegExpNodeWordCharNot ()

    + +
    +RegExpNodeWordCharNot(void);
    +
    +Constructor +

    + +
    +

    etk::~RegExpNodeWordCharNot ()

    + +
    +~RegExpNodeWordCharNot(void);
    +
    +Destructor +

    + +
    +

    parse ()

    + +
    +bool parse(const CLASS_TYPE & _data,
+           int64_t _currentPos,
+           int64_t _lenMax,
+           int64_t & _findLen);
    +
    +
    + +
    +

    display ()

    + +
    +void display(uint32_t _level);
    +
    +
    + +
    +
    + + diff --git a/etk__Semaphore.html b/etk__Semaphore.html new file mode 100644 index 0000000..c7e236c --- /dev/null +++ b/etk__Semaphore.html @@ -0,0 +1,128 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Semaphore

    +
    +

    Synopsis:

    +
    ++            Semaphore  (uint32_t _nbBasicElement,
                             uint32_t _nbMessageMax);
    +           ~Semaphore  (void);
    +  uint32_t  getCount   (void);
    +  void      post       (void);
    +  void      wait       (void);
    +  bool      wait       (uint64_t _timeOutInUs);
    + + +

    Detail:

    +

    etk::Semaphore ()

    + +
    +Semaphore(uint32_t _nbBasicElement,
+          uint32_t _nbMessageMax);
    +
    +
    + +
    +

    etk::~Semaphore ()

    + +
    +~Semaphore(void);
    +
    +
    + +
    +

    getCount ()

    + +
    +uint32_t getCount(void);
    +
    +
    + +
    +

    post ()

    + +
    +void post(void);
    +
    +
    + +
    +

    wait ()

    + +
    +void wait(void);
    +
    +
    + +
    +

    wait ()

    + +
    +bool wait(uint64_t _timeOutInUs);
    +
    +
    + +
    +
    + + diff --git a/etk__UChar.html b/etk__UChar.html new file mode 100644 index 0000000..e00963a --- /dev/null +++ b/etk__UChar.html @@ -0,0 +1,85 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::UChar

    +
    +

    Synopsis:

    +
    +
    + + +

    Object Hierarchy:

    +
    +char32_t
+    +--> etk::UChar
+
    +
    +

    Detail:

    +

    + + diff --git a/etk__Vector2D.html b/etk__Vector2D.html new file mode 100644 index 0000000..4180963 --- /dev/null +++ b/etk__Vector2D.html @@ -0,0 +1,569 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Vector2D

    +
    +

    Synopsis:

    +
    ++                       Vector2D         (void);
    +                       Vector2D         (T _x,
                                              T _y);
    +                       Vector2D         (const Vector2D<double> & obj);
    +                       Vector2D         (const Vector2D<float> & obj);
    +                       Vector2D         (const Vector2D<int32_t> & obj);
    +                       Vector2D         (const std::string & str);
    +                       Vector2D         (const std::u32string & str);
    +                      ~Vector2D         (void);
    +  const Vector2D &  operator=        (const Vector2D & obj);
    +  const Vector2D &  operator=        (const T val);
    +  bool                 operator==       (const Vector2D & obj);
    +  bool                 operator!=       (const Vector2D & obj);
    +  const Vector2D &  operator+=       (const Vector2D & obj);
    +  const Vector2D &  operator+=       (const T val);
    +  Vector2D          operator+        (const Vector2D & obj);
    +  Vector2D          operator+        (const T val);
    +  const Vector2D &  operator-=       (const Vector2D & obj);
    +  const Vector2D &  operator-=       (const T val);
    +  Vector2D          operator-        (const Vector2D & obj);
    +  Vector2D          operator-        (const T val);
    +  const Vector2D &  operator*=       (const Vector2D & obj);
    +  const Vector2D &  operator*=       (const T val);
    +  Vector2D          operator*        (const Vector2D & obj);
    +  Vector2D          operator*        (const T val);
    +  Vector2D          operator/        (const Vector2D & obj);
    +  Vector2D          operator/        (const T val);
    +  Vector2D &        operator++       ();
    +  Vector2D          operator++       (int unused);
    +  Vector2D &        operator--       ();
    +  Vector2D          operator--       (int unused);
    +  btScalar             dot              (const Vector2D & v);
    +  btScalar             length2          (void);
    +  btScalar             length           (void);
    +  btScalar             distance2        (const btVector3 & v);
    +  btScalar             distance         (const btVector3 & v);
    +  Vector3D &        normalize        (void);
    +  Vector2D          normalized       (void);
    +  Vector2D          absolute         (void);
    +  int32_t              minAxis          (void);
    +  int32_t              maxAxis          (void);
    +  int32_t              furthestAxis     (void);
    +  int32_t              closestAxis      (void);
    +  const T &            getX             ();
    +  const T &            getY             ();
    +  void                 setX             (T _x);
    +  void                 setY             (T _y);
    +  const T &            x                ();
    +  const T &            y                ();
    +  void                 operatorT*       ();
    +  void                 operatorconstT*  ();
    +  void                 setMax           (const Vector2D & other);
    +  void                 setMin           (const Vector2D & other);
    +  void                 setValue         (const T & _x,
                                              const T & _y);
    +  void                 setZero          (void);
    +  bool                 isZero           (void);
    +  void                 string           (void);
    +  void                 u32string        (void);
    + + +

    Detail:

    +

    etk::Vector2D ()

    + +
    +Vector2D(void);
    +
    +
    + +
    +

    etk::Vector2D ()

    + +
    +Vector2D(T _x,
+         T _y);
    +
    +
    + +
    +

    etk::Vector2D ()

    + +
    +Vector2D(const Vector2D<double> & obj);
    +
    +
    + +
    +

    etk::Vector2D ()

    + +
    +Vector2D(const Vector2D<float> & obj);
    +
    +
    + +
    +

    etk::Vector2D ()

    + +
    +Vector2D(const Vector2D<int32_t> & obj);
    +
    +
    + +
    +

    etk::Vector2D ()

    + +
    +Vector2D(const std::string & str);
    +
    +
    + +
    +

    etk::Vector2D ()

    + +
    +Vector2D(const std::u32string & str);
    +
    +
    + +
    +

    etk::~Vector2D ()

    + +
    +~Vector2D(void);
    +
    +
    + +
    +

    operator= ()

    + +
    +const Vector2D & operator=(const Vector2D & obj);
    +
    +
    + +
    +

    operator= ()

    + +
    +const Vector2D & operator=(const T val);
    +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const Vector2D & obj);
    +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const Vector2D & obj);
    +
    +
    + +
    +

    operator+= ()

    + +
    +const Vector2D & operator+=(const Vector2D & obj);
    +
    +
    + +
    +

    operator+= ()

    + +
    +const Vector2D & operator+=(const T val);
    +
    +
    + +
    +

    operator+ ()

    + +
    +Vector2D operator+(const Vector2D & obj);
    +
    +
    + +
    +

    operator+ ()

    + +
    +Vector2D operator+(const T val);
    +
    +
    + +
    +

    operator-= ()

    + +
    +const Vector2D & operator-=(const Vector2D & obj);
    +
    +
    + +
    +

    operator-= ()

    + +
    +const Vector2D & operator-=(const T val);
    +
    +
    + +
    +

    operator- ()

    + +
    +Vector2D operator-(const Vector2D & obj);
    +
    +
    + +
    +

    operator- ()

    + +
    +Vector2D operator-(const T val);
    +
    +
    + +
    +

    operator*= ()

    + +
    +const Vector2D & operator*=(const Vector2D & obj);
    +
    +
    + +
    +

    operator*= ()

    + +
    +const Vector2D & operator*=(const T val);
    +
    +
    + +
    +

    operator* ()

    + +
    +Vector2D operator*(const Vector2D & obj);
    +
    +
    + +
    +

    operator* ()

    + +
    +Vector2D operator*(const T val);
    +
    +
    + +
    +

    operator/ ()

    + +
    +Vector2D operator/(const Vector2D & obj);
    +
    +
    + +
    +

    operator/ ()

    + +
    +Vector2D operator/(const T val);
    +
    +
    + +
    +

    operator++ ()

    + +
    +Vector2D & operator++();
    +
    +
    + +
    +

    operator++ ()

    + +
    +Vector2D operator++(int unused);
    +
    +
    + +
    +

    operator-- ()

    + +
    +Vector2D & operator--();
    +
    +
    + +
    +

    operator-- ()

    + +
    +Vector2D operator--(int unused);
    +
    +
    + +
    +

    dot ()

    + +
    +btScalar dot(const Vector2D & v);
    +
    +Return the dot product +
    +
    + +
    +

    length2 ()

    + +
    +btScalar length2(void);
    +
    +Return the length of the vector squared +

    + +
    +

    length ()

    + +
    +btScalar length(void);
    +
    +Return the length of the vector +

    + +
    +

    distance2 ()

    + +
    +btScalar distance2(const btVector3 & v);
    +
    +Return the distance squared between the ends of this and another vector +This is symantically treating the vector like a point +

    + +
    +

    distance ()

    + +
    +btScalar distance(const btVector3 & v);
    +
    +Return the distance between the ends of this and another vector +This is symantically treating the vector like a point +

    + +
    +

    normalize ()

    + +
    +Vector3D & normalize(void);
    +
    +Normalize this vector +x^2 + y^2 + z^2 = 1 +

    + +
    +

    normalized ()

    + +
    +Vector2D normalized(void);
    +
    +Return a normalized version of this vector +

    + +
    +

    absolute ()

    + +
    +Vector2D absolute(void);
    +
    +Return a vector will the absolute values of each element +

    + +
    +

    minAxis ()

    + +
    +int32_t minAxis(void);
    +
    +Return the axis with the smallest value +Note return values are 0,1,2 for x, y, or z +

    + +
    +

    maxAxis ()

    + +
    +int32_t maxAxis(void);
    +
    +Return the axis with the largest value +Note return values are 0,1,2 for x, y, or z +

    + +
    +

    furthestAxis ()

    + +
    +int32_t furthestAxis(void);
    +
    +
    + +
    +

    closestAxis ()

    + +
    +int32_t closestAxis(void);
    +
    +
    + +
    +

    getX ()

    + +
    +const T & getX();
    +
    +Return the x value +

    + +
    +

    getY ()

    + +
    +const T & getY();
    +
    +Return the y value +

    + +
    +

    setX ()

    + +
    +void setX(T _x);
    +
    +Set the x value +

    + +
    +

    setY ()

    + +
    +void setY(T _y);
    +
    +Set the y value +

    + +
    +

    x ()

    + +
    +const T & x();
    +
    +Return the x value +

    + +
    +

    y ()

    + +
    +const T & y();
    +
    +Return the y value +

    + +
    +

    operatorT* ()

    + +
    +void operatorT*();
    +
    +
    + +
    +

    operatorconstT* ()

    + +
    +void operatorconstT*();
    +
    +
    + +
    +

    setMax ()

    + +
    +void setMax(const Vector2D & other);
    +
    +Set each element to the max of the current values and the values of another btVector3 +
    +
    + +
    +

    setMin ()

    + +
    +void setMin(const Vector2D & other);
    +
    +Set each element to the min of the current values and the values of another btVector3 +
    +
    + +
    +

    setValue ()

    + +
    +void setValue(const T & _x,
+              const T & _y);
    +
    +
    + +
    +

    setZero ()

    + +
    +void setZero(void);
    +
    +
    + +
    +

    isZero ()

    + +
    +bool isZero(void);
    +
    +
    + +
    +

    string ()

    + +
    +void string(void);
    +
    +
    + +
    +

    u32string ()

    + +
    +void u32string(void);
    +
    +
    + +
    +
    + + diff --git a/etk__Vector3D.html b/etk__Vector3D.html new file mode 100644 index 0000000..d46184a --- /dev/null +++ b/etk__Vector3D.html @@ -0,0 +1,588 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Vector3D

    +
    +

    Synopsis:

    +
    ++                 Vector3D                (void);
    +                 Vector3D                (const T & _x,
                                               const T & _y,
                                               const T & _z);
    +  Vector3D &  operator+=              (const Vector3D & v);
    +  Vector3D    operator+               (const Vector3D & v);
    +  Vector3D &  operator-=              (const Vector3D & v);
    +  Vector3D    operator-               (const Vector3D & v);
    +  Vector3D &  operator*=              (const T & s);
    +  Vector3D    operator*               (const T & s);
    +  Vector3D &  operator/=              (const Vector3D & s);
    +  Vector3D &  operator/=              (const T & s);
    +  btScalar       dot                     (const Vector3D & v);
    +  btScalar       length2                 ();
    +  btScalar       length                  ();
    +  btScalar       distance2               (const btVector3 & v);
    +  btScalar       distance                (const btVector3 & v);
    +  Vector3D &  safeNormalize           ();
    +  Vector3D &  normalize               ();
    +  Vector3D    normalized              ();
    +  Vector3D    rotate                  (const Vector3D & wAxis,
                                               const btScalar angle);
    +  btScalar       angle                   (const Vector3D & v);
    +  Vector3D    absolute                (void);
    +  Vector3D    cross                   (const Vector3D & v);
    +  T              triple                  (const Vector3D & v1,
                                               const Vector3D & v2);
    +  int32_t        minAxis                 (void);
    +  int32_t        maxAxis                 (void);
    +  int32_t        furthestAxis            (void);
    +  int32_t        closestAxis             (void);
    +  void           setInterpolate3         (const Vector3D & v0,
                                               const Vector3D & v1,
                                               T rt);
    +  Vector3D    lerp                    (const Vector3D & v,
                                               const btScalar & t);
    +  Vector3D &  operator*=              (const Vector3D & v);
    +  Vector3D    operator*               (const Vector3D & v);
    +  const T &      getX                    ();
    +  const T &      getY                    ();
    +  const T &      getZ                    ();
    +  void           setX                    (T _x);
    +  void           setY                    (T _y);
    +  void           setZ                    (T _z);
    +  void           setW                    (T _w);
    +  const T &      x                       ();
    +  const T &      y                       ();
    +  const T &      z                       ();
    +  const T &      w                       ();
    +  void           operatorT*              ();
    +  void           operatorconstT*         ();
    +  bool           operator==              (const Vector3D & other);
    +  bool           operator!=              (const Vector3D & other);
    +  void           setMax                  (const Vector3D & other);
    +  void           setMin                  (const Vector3D & other);
    +  void           setValue                (const T & _x,
                                               const T & _y,
                                               const T & _z);
    +  void           getSkewSymmetricMatrix  (Vector3D * v0,
                                               Vector3D * v1,
                                               Vector3D * v2);
    +  void           setZero                 (void);
    +  bool           isZero                  (void);
    + + +

    Detail:

    +

    etk::Vector3D ()

    + +
    +Vector3D(void);
    +
    +No initialization constructor (faster ...) +

    + +
    +

    etk::Vector3D ()

    + +
    +Vector3D(const T & _x,
+         const T & _y,
+         const T & _z);
    +
    +Constructor from scalars +
    +
    + +
    +

    operator+= ()

    + +
    +Vector3D & operator+=(const Vector3D & v);
    +
    +Add a vector to this one +
    +
    + +
    +

    operator+ ()

    + +
    +Vector3D operator+(const Vector3D & v);
    +
    +
    + +
    +

    operator-= ()

    + +
    +Vector3D & operator-=(const Vector3D & v);
    +
    +Subtract a vector from this one +
    +
    + +
    +

    operator- ()

    + +
    +Vector3D operator-(const Vector3D & v);
    +
    +
    + +
    +

    operator*= ()

    + +
    +Vector3D & operator*=(const T & s);
    +
    +Scale the vector +
    +
    + +
    +

    operator* ()

    + +
    +Vector3D operator*(const T & s);
    +
    +
    + +
    +

    operator/= ()

    + +
    +Vector3D & operator/=(const Vector3D & s);
    +
    +Inversely scale the vector +
    +
    + +
    +

    operator/= ()

    + +
    +Vector3D & operator/=(const T & s);
    +
    +
    + +
    +

    dot ()

    + +
    +btScalar dot(const Vector3D & v);
    +
    +Return the dot product +
    +
    + +
    +

    length2 ()

    + +
    +btScalar length2();
    +
    +Return the length of the vector squared +

    + +
    +

    length ()

    + +
    +btScalar length();
    +
    +Return the length of the vector +

    + +
    +

    distance2 ()

    + +
    +btScalar distance2(const btVector3 & v);
    +
    +Return the distance squared between the ends of this and another vector +This is symantically treating the vector like a point +

    + +
    +

    distance ()

    + +
    +btScalar distance(const btVector3 & v);
    +
    +Return the distance between the ends of this and another vector +This is symantically treating the vector like a point +

    + +
    +

    safeNormalize ()

    + +
    +Vector3D & safeNormalize();
    +
    +
    + +
    +

    normalize ()

    + +
    +Vector3D & normalize();
    +
    +Normalize this vector +x^2 + y^2 + z^2 = 1 +

    + +
    +

    normalized ()

    + +
    +Vector3D normalized();
    +
    +Return a normalized version of this vector +

    + +
    +

    rotate ()

    + +
    +Vector3D rotate(const Vector3D & wAxis,
+                   const btScalar angle);
    +
    +Return a rotated version of this vector +
    +
    + +
    +

    angle ()

    + +
    +btScalar angle(const Vector3D & v);
    +
    +Return the angle between this and another vector +
    +
    + +
    +

    absolute ()

    + +
    +Vector3D absolute(void);
    +
    +Return a vector will the absolute values of each element +

    + +
    +

    cross ()

    + +
    +Vector3D cross(const Vector3D & v);
    +
    +Return the cross product between this and another vector +
    +
    + +
    +

    triple ()

    + +
    +T triple(const Vector3D & v1,
+         const Vector3D & v2);
    +
    +
    + +
    +

    minAxis ()

    + +
    +int32_t minAxis(void);
    +
    +Return the axis with the smallest value +Note return values are 0,1,2 for x, y, or z +

    + +
    +

    maxAxis ()

    + +
    +int32_t maxAxis(void);
    +
    +Return the axis with the largest value +Note return values are 0,1,2 for x, y, or z +

    + +
    +

    furthestAxis ()

    + +
    +int32_t furthestAxis(void);
    +
    +
    + +
    +

    closestAxis ()

    + +
    +int32_t closestAxis(void);
    +
    +
    + +
    +

    setInterpolate3 ()

    + +
    +void setInterpolate3(const Vector3D & v0,
+                     const Vector3D & v1,
+                     T rt);
    +
    +
    + +
    +

    lerp ()

    + +
    +Vector3D lerp(const Vector3D & v,
+                 const btScalar & t);
    +
    +Return the linear interpolation between this and another vector +
    +
    + +
    +

    operator*= ()

    + +
    +Vector3D & operator*=(const Vector3D & v);
    +
    +Elementwise multiply this vector by the other +
    +
    + +
    +

    operator* ()

    + +
    +Vector3D operator*(const Vector3D & v);
    +
    +
    + +
    +

    getX ()

    + +
    +const T & getX();
    +
    +Return the x value +

    + +
    +

    getY ()

    + +
    +const T & getY();
    +
    +Return the y value +

    + +
    +

    getZ ()

    + +
    +const T & getZ();
    +
    +Return the z value +

    + +
    +

    setX ()

    + +
    +void setX(T _x);
    +
    +Set the x value +

    + +
    +

    setY ()

    + +
    +void setY(T _y);
    +
    +Set the y value +

    + +
    +

    setZ ()

    + +
    +void setZ(T _z);
    +
    +Set the z value +

    + +
    +

    setW ()

    + +
    +void setW(T _w);
    +
    +Set the w value +

    + +
    +

    x ()

    + +
    +const T & x();
    +
    +Return the x value +

    + +
    +

    y ()

    + +
    +const T & y();
    +
    +Return the y value +

    + +
    +

    z ()

    + +
    +const T & z();
    +
    +Return the z value +

    + +
    +

    w ()

    + +
    +const T & w();
    +
    +Return the w value +

    + +
    +

    operatorT* ()

    + +
    +void operatorT*();
    +
    +
    + +
    +

    operatorconstT* ()

    + +
    +void operatorconstT*();
    +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const Vector3D & other);
    +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const Vector3D & other);
    +
    +
    + +
    +

    setMax ()

    + +
    +void setMax(const Vector3D & other);
    +
    +Set each element to the max of the current values and the values of another btVector3 +
    +
    + +
    +

    setMin ()

    + +
    +void setMin(const Vector3D & other);
    +
    +Set each element to the min of the current values and the values of another btVector3 +
    +
    + +
    +

    setValue ()

    + +
    +void setValue(const T & _x,
+              const T & _y,
+              const T & _z);
    +
    +
    + +
    +

    getSkewSymmetricMatrix ()

    + +
    +void getSkewSymmetricMatrix(Vector3D * v0,
+                            Vector3D * v1,
+                            Vector3D * v2);
    +
    +
    + +
    +

    setZero ()

    + +
    +void setZero(void);
    +
    +
    + +
    +

    isZero ()

    + +
    +bool isZero(void);
    +
    +
    + +
    +
    + + diff --git a/etk__Vector4D.html b/etk__Vector4D.html new file mode 100644 index 0000000..e5ed679 --- /dev/null +++ b/etk__Vector4D.html @@ -0,0 +1,496 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::Vector4D

    +
    +

    Synopsis:

    +
    ++                 Vector4D         (void);
    +                 Vector4D         (const T & _x,
                                        const T & _y,
                                        const T & _z,
                                        const T & _w);
    +  Vector4D &  operator+=       (const Vector4D & v);
    +  Vector4D    operator+        (const Vector4D & v);
    +  Vector4D &  operator-=       (const Vector4D & v);
    +  Vector4D    operator-        (const Vector4D & v);
    +  Vector4D &  operator*=       (const T & s);
    +  Vector4D    operator*        (const T & s);
    +  Vector4D &  operator/=       (const Vector4D & s);
    +  Vector4D &  operator/=       (const T & s);
    +  float          dot              (const Vector4D & v);
    +  float          length2          ();
    +  float          length           ();
    +  float          distance2        (const Vector4D & v);
    +  float          distance         (const Vector4D & v);
    +  Vector4D &  normalize        ();
    +  Vector4D    normalized       ();
    +  Vector4D    absolute         (void);
    +  Vector4D &  operator*=       (const Vector4D & v);
    +  Vector4D    operator*        (const Vector4D & v);
    +  const T &      getX             ();
    +  const T &      getY             ();
    +  const T &      getZ             ();
    +  const T &      getW             ();
    +  void           setX             (T _x);
    +  void           setY             (T _y);
    +  void           setZ             (T _z);
    +  void           setW             (T _w);
    +  const T &      x                ();
    +  const T &      y                ();
    +  const T &      z                ();
    +  const T &      w                ();
    +  void           operatorT*       ();
    +  void           operatorconstT*  ();
    +  bool           operator==       (const Vector4D & other);
    +  bool           operator!=       (const Vector4D & other);
    +  void           setMax           (const Vector4D & other);
    +  void           setMin           (const Vector4D & other);
    +  void           setValue         (const T & _x,
                                        const T & _y,
                                        const T & _z,
                                        const T & _w);
    +  void           setZero          (void);
    +  bool           isZero           (void);
    + + +

    Detail:

    +

    etk::Vector4D ()

    + +
    +Vector4D(void);
    +
    +No initialization constructor (faster ...) +

    + +
    +

    etk::Vector4D ()

    + +
    +Vector4D(const T & _x,
+         const T & _y,
+         const T & _z,
+         const T & _w);
    +
    +Constructor from scalars +
    +
    + +
    +

    operator+= ()

    + +
    +Vector4D & operator+=(const Vector4D & v);
    +
    +Add a vector to this one +
    +
    + +
    +

    operator+ ()

    + +
    +Vector4D operator+(const Vector4D & v);
    +
    +
    + +
    +

    operator-= ()

    + +
    +Vector4D & operator-=(const Vector4D & v);
    +
    +Subtract a vector from this one +
    +
    + +
    +

    operator- ()

    + +
    +Vector4D operator-(const Vector4D & v);
    +
    +
    + +
    +

    operator*= ()

    + +
    +Vector4D & operator*=(const T & s);
    +
    +Scale the vector +
    +
    + +
    +

    operator* ()

    + +
    +Vector4D operator*(const T & s);
    +
    +
    + +
    +

    operator/= ()

    + +
    +Vector4D & operator/=(const Vector4D & s);
    +
    +Inversely scale the vector +
    +
    + +
    +

    operator/= ()

    + +
    +Vector4D & operator/=(const T & s);
    +
    +
    + +
    +

    dot ()

    + +
    +float dot(const Vector4D & v);
    +
    +Return the dot product +
    +
    + +
    +

    length2 ()

    + +
    +float length2();
    +
    +Return the length of the vector squared +

    + +
    +

    length ()

    + +
    +float length();
    +
    +Return the length of the vector +

    + +
    +

    distance2 ()

    + +
    +float distance2(const Vector4D & v);
    +
    +Return the distance squared between the ends of this and another vector +This is symantically treating the vector like a point +

    + +
    +

    distance ()

    + +
    +float distance(const Vector4D & v);
    +
    +Return the distance between the ends of this and another vector +This is symantically treating the vector like a point +

    + +
    +

    normalize ()

    + +
    +Vector4D & normalize();
    +
    +Normalize this vector +x^2 + y^2 + z^2 = 1 +

    + +
    +

    normalized ()

    + +
    +Vector4D normalized();
    +
    +Return a normalized version of this vector +

    + +
    +

    absolute ()

    + +
    +Vector4D absolute(void);
    +
    +Return a rotated version of this vector +
    Return the angle between this and another vector +
    Return a vector will the absolute values of each element +
    +
    + +
    +

    operator*= ()

    + +
    +Vector4D & operator*=(const Vector4D & v);
    +
    +Return the cross product between this and another vector +
    Return the axis with the smallest value +Note return values are 0,1,2 for x, y, or z +//** +
    Return the axis with the largest value +Note return values are 0,1,2 for x, y, or z +//** +
    Return the linear interpolation between this and another vector +
    Elementwise multiply this vector by the other +
    +
    + +
    +

    operator* ()

    + +
    +Vector4D operator*(const Vector4D & v);
    +
    +
    + +
    +

    getX ()

    + +
    +const T & getX();
    +
    +Return the x value +

    + +
    +

    getY ()

    + +
    +const T & getY();
    +
    +Return the y value +

    + +
    +

    getZ ()

    + +
    +const T & getZ();
    +
    +Return the z value +

    + +
    +

    getW ()

    + +
    +const T & getW();
    +
    +Return the z value +

    + +
    +

    setX ()

    + +
    +void setX(T _x);
    +
    +Set the x value +

    + +
    +

    setY ()

    + +
    +void setY(T _y);
    +
    +Set the y value +

    + +
    +

    setZ ()

    + +
    +void setZ(T _z);
    +
    +Set the z value +

    + +
    +

    setW ()

    + +
    +void setW(T _w);
    +
    +Set the w value +

    + +
    +

    x ()

    + +
    +const T & x();
    +
    +Return the x value +

    + +
    +

    y ()

    + +
    +const T & y();
    +
    +Return the y value +

    + +
    +

    z ()

    + +
    +const T & z();
    +
    +Return the z value +

    + +
    +

    w ()

    + +
    +const T & w();
    +
    +Return the w value +

    + +
    +

    operatorT* ()

    + +
    +void operatorT*();
    +
    +
    + +
    +

    operatorconstT* ()

    + +
    +void operatorconstT*();
    +
    +
    + +
    +

    operator== ()

    + +
    +bool operator==(const Vector4D & other);
    +
    +
    + +
    +

    operator!= ()

    + +
    +bool operator!=(const Vector4D & other);
    +
    +
    + +
    +

    setMax ()

    + +
    +void setMax(const Vector4D & other);
    +
    +Set each element to the max of the current values and the values of another btVector3 +
    +
    + +
    +

    setMin ()

    + +
    +void setMin(const Vector4D & other);
    +
    +Set each element to the min of the current values and the values of another btVector3 +
    +
    + +
    +

    setValue ()

    + +
    +void setValue(const T & _x,
+              const T & _y,
+              const T & _z,
+              const T & _w);
    +
    +
    + +
    +

    setZero ()

    + +
    +void setZero(void);
    +
    +
    + +
    +

    isZero ()

    + +
    +bool isZero(void);
    +
    +
    + +
    +
    + + diff --git a/etk__archive__Zip.html b/etk__archive__Zip.html new file mode 100644 index 0000000..5f9e394 --- /dev/null +++ b/etk__archive__Zip.html @@ -0,0 +1,109 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::archive::Zip

    +
    +

    Synopsis:

    +
    ++        Zip       (const std::string & _fileName);
    +       ~Zip       (void);
    #  void  loadFile  (int32_t _id);
    + + +

    Object Hierarchy:

    +
    +etk::Archive
+    +--> etk::archive::Zip
+
    +
    +

    Detail:

    +

    etk::archive::Zip ()

    + +
    +Zip(const std::string & _fileName);
    +
    +
    + +
    +

    etk::archive::~Zip ()

    + +
    +~Zip(void);
    +
    +
    + +
    +

    loadFile ()

    + +
    +void loadFile(int32_t _id);
    +
    +
    + +
    +
    + + diff --git a/etk__elementPos_ts.html b/etk__elementPos_ts.html new file mode 100644 index 0000000..52133dc --- /dev/null +++ b/etk__elementPos_ts.html @@ -0,0 +1,79 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Class: etk::elementPos_ts

    +
    +

    Synopsis:

    +
    +
    + + +

    Detail:

    +

    + + diff --git a/etk__logLevel.html b/etk__logLevel.html new file mode 100644 index 0000000..bf2730e --- /dev/null +++ b/etk__logLevel.html @@ -0,0 +1,76 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Enum: etk::logLevel

    +
    +Value :
    + +
    + + diff --git a/etk__regExpPrivateSection.html b/etk__regExpPrivateSection.html new file mode 100644 index 0000000..dab6027 --- /dev/null +++ b/etk__regExpPrivateSection.html @@ -0,0 +1,76 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Enum: etk::regExpPrivateSection

    +
    +Value :
    + +
    + + diff --git a/etk__seekNode.html b/etk__seekNode.html new file mode 100644 index 0000000..486f6c6 --- /dev/null +++ b/etk__seekNode.html @@ -0,0 +1,76 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Enum: etk::seekNode

    +
    +Value :
    + +
    + + diff --git a/etk__typeNode.html b/etk__typeNode.html new file mode 100644 index 0000000..c74a9fd --- /dev/null +++ b/etk__typeNode.html @@ -0,0 +1,76 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Enum: etk::typeNode

    +
    +Value :
    + +
    + + diff --git a/index.html b/index.html new file mode 100644 index 0000000..a1d393e --- /dev/null +++ b/index.html @@ -0,0 +1,71 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    etk


    TODO : Main page ...

    + + diff --git a/unicode__charset.html b/unicode__charset.html new file mode 100644 index 0000000..ca196e2 --- /dev/null +++ b/unicode__charset.html @@ -0,0 +1,76 @@ + + + + + etk Library + + + +
    +
    +

    etk Library

    +
  • etk
    • + +
  • FSNType
    • +
  • logLevel
    • +
  • regExpPrivateSection
    • +
  • seekNode
    • +
  • typeNode
    • + +
  • unicode
    • + +
    +
    +
    +

    Enum: unicode::charset

    +
    +Value :
    + +
    + +