@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/cpp.json

@@ -0,0 +1,348 @@
+{
+  "language": "cpp",
+  "definitions": {
+    "std::string": {
+      "signature": "using string = std::basic_string<char>",
+      "description": "Dynamic character string class providing automatic memory management, concatenation, comparison, and search operations.",
+      "type": "class",
+      "module": "<string>",
+      "members": {
+        "size": { "signature": "size_type size() const noexcept", "description": "Returns the number of characters in the string.", "type": "method" },
+        "length": { "signature": "size_type length() const noexcept", "description": "Returns the number of characters (same as size).", "type": "method" },
+        "empty": { "signature": "bool empty() const noexcept", "description": "Returns true if the string has no characters.", "type": "method" },
+        "c_str": { "signature": "const char* c_str() const noexcept", "description": "Returns a null-terminated C-style string.", "type": "method" },
+        "data": { "signature": "const char* data() const noexcept", "description": "Returns a pointer to the underlying character array.", "type": "method" },
+        "substr": { "signature": "string substr(size_type pos = 0, size_type count = npos) const", "description": "Returns a substring starting at pos with length count.", "type": "method" },
+        "find": { "signature": "size_type find(const string& str, size_type pos = 0) const noexcept", "description": "Finds the first occurrence of the substring.", "type": "method" },
+        "rfind": { "signature": "size_type rfind(const string& str, size_type pos = npos) const noexcept", "description": "Finds the last occurrence of the substring.", "type": "method" },
+        "append": { "signature": "string& append(const string& str)", "description": "Appends the given string to the end.", "type": "method" },
+        "insert": { "signature": "string& insert(size_type pos, const string& str)", "description": "Inserts characters at the specified position.", "type": "method" },
+        "erase": { "signature": "string& erase(size_type pos = 0, size_type count = npos)", "description": "Erases characters from the string.", "type": "method" },
+        "replace": { "signature": "string& replace(size_type pos, size_type count, const string& str)", "description": "Replaces part of the string with another string.", "type": "method" },
+        "compare": { "signature": "int compare(const string& str) const noexcept", "description": "Compares this string to another.", "type": "method" },
+        "starts_with": { "signature": "bool starts_with(std::string_view sv) const noexcept", "description": "Checks if the string starts with the given prefix (C++20).", "type": "method" },
+        "ends_with": { "signature": "bool ends_with(std::string_view sv) const noexcept", "description": "Checks if the string ends with the given suffix (C++20).", "type": "method" },
+        "contains": { "signature": "bool contains(std::string_view sv) const noexcept", "description": "Checks if the string contains the given substring (C++23).", "type": "method" },
+        "reserve": { "signature": "void reserve(size_type new_cap)", "description": "Reserves storage to avoid reallocations.", "type": "method" },
+        "clear": { "signature": "void clear() noexcept", "description": "Clears the contents of the string.", "type": "method" },
+        "push_back": { "signature": "void push_back(char ch)", "description": "Appends a character to the end.", "type": "method" },
+        "pop_back": { "signature": "void pop_back()", "description": "Removes the last character.", "type": "method" },
+        "begin": { "signature": "iterator begin() noexcept", "description": "Returns an iterator to the first character.", "type": "method" },
+        "end": { "signature": "iterator end() noexcept", "description": "Returns an iterator past the last character.", "type": "method" }
+      }
+    },
+    "std::vector": {
+      "signature": "template<class T, class Allocator = std::allocator<T>> class vector",
+      "description": "Dynamic contiguous array with automatic memory management. Supports amortized O(1) push_back and O(1) random access. The most commonly used container in C++.",
+      "type": "class",
+      "module": "<vector>",
+      "members": {
+        "push_back": { "signature": "void push_back(const T& value)", "description": "Appends an element to the end of the vector.", "type": "method" },
+        "emplace_back": { "signature": "template<class... Args> reference emplace_back(Args&&... args)", "description": "Constructs an element in-place at the end.", "type": "method" },
+        "pop_back": { "signature": "void pop_back()", "description": "Removes the last element.", "type": "method" },
+        "size": { "signature": "size_type size() const noexcept", "description": "Returns the number of elements.", "type": "method" },
+        "empty": { "signature": "bool empty() const noexcept", "description": "Returns true if the vector has no elements.", "type": "method" },
+        "capacity": { "signature": "size_type capacity() const noexcept", "description": "Returns the number of elements that can be held in currently allocated storage.", "type": "method" },
+        "reserve": { "signature": "void reserve(size_type new_cap)", "description": "Reserves storage for at least new_cap elements.", "type": "method" },
+        "shrink_to_fit": { "signature": "void shrink_to_fit()", "description": "Requests removal of unused capacity.", "type": "method" },
+        "resize": { "signature": "void resize(size_type count)", "description": "Resizes the container to contain count elements.", "type": "method" },
+        "clear": { "signature": "void clear() noexcept", "description": "Erases all elements from the vector.", "type": "method" },
+        "at": { "signature": "reference at(size_type pos)", "description": "Returns element at pos with bounds checking.", "type": "method" },
+        "front": { "signature": "reference front()", "description": "Returns a reference to the first element.", "type": "method" },
+        "back": { "signature": "reference back()", "description": "Returns a reference to the last element.", "type": "method" },
+        "data": { "signature": "T* data() noexcept", "description": "Returns a pointer to the underlying array.", "type": "method" },
+        "insert": { "signature": "iterator insert(const_iterator pos, const T& value)", "description": "Inserts an element before the given position.", "type": "method" },
+        "erase": { "signature": "iterator erase(const_iterator pos)", "description": "Erases the element at the given position.", "type": "method" },
+        "begin": { "signature": "iterator begin() noexcept", "description": "Returns an iterator to the first element.", "type": "method" },
+        "end": { "signature": "iterator end() noexcept", "description": "Returns an iterator past the last element.", "type": "method" },
+        "rbegin": { "signature": "reverse_iterator rbegin() noexcept", "description": "Returns a reverse iterator to the last element.", "type": "method" },
+        "rend": { "signature": "reverse_iterator rend() noexcept", "description": "Returns a reverse iterator before the first element.", "type": "method" }
+      }
+    },
+    "std::map": {
+      "signature": "template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>> class map",
+      "description": "Sorted associative container storing unique key-value pairs, ordered by keys using a red-black tree. O(log n) lookup, insertion, and removal.",
+      "type": "class",
+      "module": "<map>",
+      "members": {
+        "insert": { "signature": "std::pair<iterator, bool> insert(const value_type& value)", "description": "Inserts a key-value pair if the key does not exist.", "type": "method" },
+        "emplace": { "signature": "template<class... Args> std::pair<iterator, bool> emplace(Args&&... args)", "description": "Constructs a key-value pair in-place.", "type": "method" },
+        "erase": { "signature": "size_type erase(const Key& key)", "description": "Removes the element with the given key.", "type": "method" },
+        "find": { "signature": "iterator find(const Key& key)", "description": "Finds an element with the given key.", "type": "method" },
+        "count": { "signature": "size_type count(const Key& key) const", "description": "Returns the number of elements with the given key (0 or 1).", "type": "method" },
+        "contains": { "signature": "bool contains(const Key& key) const", "description": "Checks if the map contains an element with the given key (C++20).", "type": "method" },
+        "at": { "signature": "T& at(const Key& key)", "description": "Returns a reference to the mapped value with bounds checking.", "type": "method" },
+        "operator[]": { "signature": "T& operator[](const Key& key)", "description": "Returns a reference to the mapped value, inserting a default if not present.", "type": "method" },
+        "size": { "signature": "size_type size() const noexcept", "description": "Returns the number of key-value pairs.", "type": "method" },
+        "empty": { "signature": "bool empty() const noexcept", "description": "Returns true if the map is empty.", "type": "method" },
+        "clear": { "signature": "void clear() noexcept", "description": "Removes all elements.", "type": "method" },
+        "begin": { "signature": "iterator begin() noexcept", "description": "Returns an iterator to the first element.", "type": "method" },
+        "end": { "signature": "iterator end() noexcept", "description": "Returns an iterator past the last element.", "type": "method" },
+        "lower_bound": { "signature": "iterator lower_bound(const Key& key)", "description": "Returns an iterator to the first element not less than key.", "type": "method" },
+        "upper_bound": { "signature": "iterator upper_bound(const Key& key)", "description": "Returns an iterator to the first element greater than key.", "type": "method" }
+      }
+    },
+    "std::unordered_map": {
+      "signature": "template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>> class unordered_map",
+      "description": "Hash-based associative container storing unique key-value pairs. Average O(1) lookup, insertion, and removal.",
+      "type": "class",
+      "module": "<unordered_map>",
+      "members": {
+        "insert": { "signature": "std::pair<iterator, bool> insert(const value_type& value)", "description": "Inserts a key-value pair if the key does not exist.", "type": "method" },
+        "emplace": { "signature": "template<class... Args> std::pair<iterator, bool> emplace(Args&&... args)", "description": "Constructs a key-value pair in-place.", "type": "method" },
+        "erase": { "signature": "size_type erase(const Key& key)", "description": "Removes the element with the given key.", "type": "method" },
+        "find": { "signature": "iterator find(const Key& key)", "description": "Finds an element with the given key.", "type": "method" },
+        "count": { "signature": "size_type count(const Key& key) const", "description": "Returns the number of elements with the given key (0 or 1).", "type": "method" },
+        "contains": { "signature": "bool contains(const Key& key) const", "description": "Checks if the map contains an element with the given key (C++20).", "type": "method" },
+        "at": { "signature": "T& at(const Key& key)", "description": "Returns a reference to the mapped value with bounds checking.", "type": "method" },
+        "operator[]": { "signature": "T& operator[](const Key& key)", "description": "Returns a reference to the mapped value, inserting a default if not present.", "type": "method" },
+        "size": { "signature": "size_type size() const noexcept", "description": "Returns the number of elements.", "type": "method" },
+        "empty": { "signature": "bool empty() const noexcept", "description": "Returns true if the map is empty.", "type": "method" },
+        "clear": { "signature": "void clear() noexcept", "description": "Removes all elements.", "type": "method" },
+        "bucket_count": { "signature": "size_type bucket_count() const noexcept", "description": "Returns the number of buckets.", "type": "method" },
+        "load_factor": { "signature": "float load_factor() const noexcept", "description": "Returns the average number of elements per bucket.", "type": "method" },
+        "reserve": { "signature": "void reserve(size_type count)", "description": "Reserves space for at least count elements.", "type": "method" }
+      }
+    },
+    "std::set": {
+      "signature": "template<class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key>> class set",
+      "description": "Sorted associative container of unique elements implemented as a red-black tree. O(log n) insertion, removal, and lookup.",
+      "type": "class",
+      "module": "<set>",
+      "members": {
+        "insert": { "signature": "std::pair<iterator, bool> insert(const value_type& value)", "description": "Inserts an element if not already present.", "type": "method" },
+        "emplace": { "signature": "template<class... Args> std::pair<iterator, bool> emplace(Args&&... args)", "description": "Constructs an element in-place.", "type": "method" },
+        "erase": { "signature": "size_type erase(const Key& key)", "description": "Removes the element with the given value.", "type": "method" },
+        "find": { "signature": "iterator find(const Key& key) const", "description": "Finds an element with the given value.", "type": "method" },
+        "count": { "signature": "size_type count(const Key& key) const", "description": "Returns how many elements match the key (0 or 1).", "type": "method" },
+        "contains": { "signature": "bool contains(const Key& key) const", "description": "Checks if the set contains the given value (C++20).", "type": "method" },
+        "size": { "signature": "size_type size() const noexcept", "description": "Returns the number of elements.", "type": "method" },
+        "empty": { "signature": "bool empty() const noexcept", "description": "Returns true if the set is empty.", "type": "method" },
+        "clear": { "signature": "void clear() noexcept", "description": "Removes all elements.", "type": "method" },
+        "begin": { "signature": "iterator begin() const noexcept", "description": "Returns an iterator to the first element.", "type": "method" },
+        "end": { "signature": "iterator end() const noexcept", "description": "Returns an iterator past the last element.", "type": "method" },
+        "lower_bound": { "signature": "iterator lower_bound(const Key& key) const", "description": "Returns an iterator to the first element not less than key.", "type": "method" },
+        "upper_bound": { "signature": "iterator upper_bound(const Key& key) const", "description": "Returns an iterator to the first element greater than key.", "type": "method" }
+      }
+    },
+    "std::unique_ptr": {
+      "signature": "template<class T, class Deleter = std::default_delete<T>> class unique_ptr",
+      "description": "Smart pointer with exclusive ownership semantics. Cannot be copied, only moved. Automatically deletes the managed object when the unique_ptr goes out of scope.",
+      "type": "class",
+      "module": "<memory>",
+      "members": {
+        "get": { "signature": "pointer get() const noexcept", "description": "Returns the stored pointer without releasing ownership.", "type": "method" },
+        "release": { "signature": "pointer release() noexcept", "description": "Releases ownership of the managed object and returns the raw pointer.", "type": "method" },
+        "reset": { "signature": "void reset(pointer ptr = pointer()) noexcept", "description": "Replaces the managed object, deleting the old one.", "type": "method" },
+        "swap": { "signature": "void swap(unique_ptr& other) noexcept", "description": "Swaps the managed objects and associated deleters.", "type": "method" },
+        "operator*": { "signature": "T& operator*() const", "description": "Dereferences the stored pointer.", "type": "method" },
+        "operator->": { "signature": "pointer operator->() const noexcept", "description": "Returns the stored pointer for member access.", "type": "method" },
+        "operator bool": { "signature": "explicit operator bool() const noexcept", "description": "Checks if the pointer is non-null.", "type": "method" }
+      }
+    },
+    "std::shared_ptr": {
+      "signature": "template<class T> class shared_ptr",
+      "description": "Smart pointer with shared (reference-counted) ownership. Multiple shared_ptr instances can own the same object. The object is destroyed when the last shared_ptr owning it is destroyed.",
+      "type": "class",
+      "module": "<memory>",
+      "members": {
+        "get": { "signature": "T* get() const noexcept", "description": "Returns the stored pointer.", "type": "method" },
+        "reset": { "signature": "void reset() noexcept", "description": "Releases ownership. If last owner, deletes the object.", "type": "method" },
+        "use_count": { "signature": "long use_count() const noexcept", "description": "Returns the number of shared_ptr instances sharing ownership.", "type": "method" },
+        "unique": { "signature": "bool unique() const noexcept", "description": "Returns true if this is the only owner (deprecated in C++17, removed in C++20).", "type": "method" },
+        "swap": { "signature": "void swap(shared_ptr& other) noexcept", "description": "Swaps the managed objects.", "type": "method" },
+        "operator*": { "signature": "T& operator*() const noexcept", "description": "Dereferences the stored pointer.", "type": "method" },
+        "operator->": { "signature": "T* operator->() const noexcept", "description": "Returns the stored pointer for member access.", "type": "method" },
+        "operator bool": { "signature": "explicit operator bool() const noexcept", "description": "Checks if the pointer is non-null.", "type": "method" }
+      }
+    },
+    "std::optional": {
+      "signature": "template<class T> class optional",
+      "description": "Manages an optional contained value — a value that may or may not be present. Useful as a return type for functions that may fail without using exceptions or sentinel values. (C++17)",
+      "type": "class",
+      "module": "<optional>",
+      "members": {
+        "value": { "signature": "T& value()", "description": "Returns the contained value with bounds checking (throws std::bad_optional_access if empty).", "type": "method" },
+        "value_or": { "signature": "template<class U> T value_or(U&& default_value) const&", "description": "Returns the contained value if present, otherwise the given default.", "type": "method" },
+        "has_value": { "signature": "bool has_value() const noexcept", "description": "Returns true if the optional contains a value.", "type": "method" },
+        "reset": { "signature": "void reset() noexcept", "description": "Destroys the contained value, making the optional empty.", "type": "method" },
+        "emplace": { "signature": "template<class... Args> T& emplace(Args&&... args)", "description": "Constructs the contained value in-place.", "type": "method" },
+        "operator*": { "signature": "T& operator*() &", "description": "Accesses the contained value (no bounds checking).", "type": "method" },
+        "operator->": { "signature": "const T* operator->() const", "description": "Accesses members of the contained value.", "type": "method" },
+        "operator bool": { "signature": "explicit operator bool() const noexcept", "description": "Returns true if the optional contains a value.", "type": "method" }
+      }
+    },
+    "std::array": {
+      "signature": "template<class T, std::size_t N> struct array",
+      "description": "Fixed-size container wrapping a C-style array. Provides STL-compatible interface with bounds checking via at(). Stack-allocated with zero overhead compared to built-in arrays.",
+      "type": "class",
+      "module": "<array>",
+      "members": {
+        "at": { "signature": "reference at(size_type pos)", "description": "Returns element at pos with bounds checking.", "type": "method" },
+        "operator[]": { "signature": "reference operator[](size_type pos)", "description": "Returns element at pos (no bounds checking).", "type": "method" },
+        "front": { "signature": "reference front()", "description": "Returns the first element.", "type": "method" },
+        "back": { "signature": "reference back()", "description": "Returns the last element.", "type": "method" },
+        "data": { "signature": "T* data() noexcept", "description": "Returns a pointer to the underlying C-style array.", "type": "method" },
+        "size": { "signature": "constexpr size_type size() const noexcept", "description": "Returns the number of elements (always N).", "type": "method" },
+        "empty": { "signature": "constexpr bool empty() const noexcept", "description": "Returns true if the array is empty (N == 0).", "type": "method" },
+        "fill": { "signature": "void fill(const T& value)", "description": "Fills all elements with the given value.", "type": "method" },
+        "swap": { "signature": "void swap(array& other) noexcept(...)", "description": "Swaps contents with another array.", "type": "method" },
+        "begin": { "signature": "iterator begin() noexcept", "description": "Returns an iterator to the first element.", "type": "method" },
+        "end": { "signature": "iterator end() noexcept", "description": "Returns an iterator past the last element.", "type": "method" }
+      }
+    },
+    "std::pair": {
+      "signature": "template<class T1, class T2> struct pair",
+      "description": "Holds two heterogeneous objects as a single unit. Commonly used as the value type of std::map and as a return type for multiple values.",
+      "type": "class",
+      "module": "<utility>",
+      "members": {
+        "first": { "signature": "T1 first", "description": "The first element of the pair.", "type": "property" },
+        "second": { "signature": "T2 second", "description": "The second element of the pair.", "type": "property" }
+      }
+    },
+    "std::tuple": {
+      "signature": "template<class... Types> class tuple",
+      "description": "Fixed-size heterogeneous collection of values. Generalizes std::pair to an arbitrary number of elements. Supports structured bindings (C++17).",
+      "type": "class",
+      "module": "<tuple>",
+      "members": {
+        "std::get": { "signature": "template<std::size_t I, class... Types> auto& get(tuple<Types...>& t) noexcept", "description": "Extracts the I-th element from the tuple.", "type": "function" },
+        "std::tuple_size": { "signature": "template<class T> struct tuple_size", "description": "Provides the number of elements in a tuple at compile time.", "type": "class" },
+        "std::tuple_element": { "signature": "template<std::size_t I, class T> struct tuple_element", "description": "Provides the type of the I-th element of a tuple.", "type": "class" },
+        "std::make_tuple": { "signature": "template<class... Types> tuple<VTypes...> make_tuple(Types&&... args)", "description": "Creates a tuple from the given arguments.", "type": "function" },
+        "std::tie": { "signature": "template<class... Types> tuple<Types&...> tie(Types&... args) noexcept", "description": "Creates a tuple of lvalue references.", "type": "function" }
+      }
+    },
+    "std::function": {
+      "signature": "template<class R, class... Args> class function<R(Args...)>",
+      "description": "General-purpose polymorphic function wrapper. Can store, copy, and invoke any callable target — functions, lambdas, bind expressions, and other function objects.",
+      "type": "class",
+      "module": "<functional>",
+      "members": {
+        "operator()": { "signature": "R operator()(Args... args) const", "description": "Invokes the stored callable with the given arguments.", "type": "method" },
+        "operator bool": { "signature": "explicit operator bool() const noexcept", "description": "Returns true if the function object has a callable target.", "type": "method" },
+        "target": { "signature": "template<class T> T* target() noexcept", "description": "Returns a pointer to the stored callable if type matches, else nullptr.", "type": "method" },
+        "swap": { "signature": "void swap(function& other) noexcept", "description": "Swaps the stored callable targets.", "type": "method" }
+      }
+    },
+    "std::weak_ptr": {
+      "signature": "template<class T> class weak_ptr",
+      "description": "Non-owning smart pointer that holds a weak reference to a std::shared_ptr-managed object. Does not affect the reference count. Used to break circular references.",
+      "type": "class",
+      "module": "<memory>",
+      "members": {
+        "lock": { "signature": "shared_ptr<T> lock() const noexcept", "description": "Creates a shared_ptr that shares ownership of the managed object. Returns empty shared_ptr if expired.", "type": "method" },
+        "expired": { "signature": "bool expired() const noexcept", "description": "Returns true if the managed object has been deleted.", "type": "method" },
+        "use_count": { "signature": "long use_count() const noexcept", "description": "Returns the number of shared_ptr instances sharing ownership.", "type": "method" },
+        "reset": { "signature": "void reset() noexcept", "description": "Releases the reference to the managed object.", "type": "method" },
+        "swap": { "signature": "void swap(weak_ptr& other) noexcept", "description": "Swaps the managed objects.", "type": "method" }
+      }
+    },
+    "std::make_unique": {
+      "signature": "template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args)",
+      "description": "Constructs an object of type T and wraps it in a std::unique_ptr. Preferred over using new directly. Exception-safe. (C++14)",
+      "type": "function",
+      "module": "<memory>"
+    },
+    "std::make_shared": {
+      "signature": "template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args)",
+      "description": "Constructs an object of type T and wraps it in a std::shared_ptr. Performs a single allocation for both the object and the control block.",
+      "type": "function",
+      "module": "<memory>"
+    },
+    "std::move": {
+      "signature": "template<class T> constexpr std::remove_reference_t<T>&& move(T&& t) noexcept",
+      "description": "Casts its argument to an rvalue reference, indicating that it may be moved from. Enables move semantics for efficient transfer of resources.",
+      "type": "function",
+      "module": "<utility>"
+    },
+    "std::forward": {
+      "signature": "template<class T> constexpr T&& forward(std::remove_reference_t<T>& t) noexcept",
+      "description": "Forwards lvalues as lvalues and rvalues as rvalues. Used in template code to implement perfect forwarding.",
+      "type": "function",
+      "module": "<utility>"
+    },
+    "std::sort": {
+      "signature": "template<class RandomIt> void sort(RandomIt first, RandomIt last)",
+      "description": "Sorts elements in [first, last) in ascending order. Uses introsort (hybrid of quicksort, heapsort, and insertion sort). Average and worst-case O(n log n).",
+      "type": "function",
+      "module": "<algorithm>"
+    },
+    "std::find": {
+      "signature": "template<class InputIt, class T> InputIt find(InputIt first, InputIt last, const T& value)",
+      "description": "Returns an iterator to the first element in [first, last) that equals value. Returns last if not found. O(n).",
+      "type": "function",
+      "module": "<algorithm>"
+    },
+    "std::accumulate": {
+      "signature": "template<class InputIt, class T> T accumulate(InputIt first, InputIt last, T init)",
+      "description": "Computes the sum of the given initial value and the elements in the range [first, last). Can also accept a custom binary operation.",
+      "type": "function",
+      "module": "<numeric>"
+    },
+    "std::transform": {
+      "signature": "template<class InputIt, class OutputIt, class UnaryOp> OutputIt transform(InputIt first, InputIt last, OutputIt d_first, UnaryOp op)",
+      "description": "Applies the given function to each element in [first, last) and stores the result in the range beginning at d_first.",
+      "type": "function",
+      "module": "<algorithm>"
+    },
+    "std::for_each": {
+      "signature": "template<class InputIt, class UnaryFunc> UnaryFunc for_each(InputIt first, InputIt last, UnaryFunc f)",
+      "description": "Applies the given function to each element in [first, last). Returns the function object after all applications.",
+      "type": "function",
+      "module": "<algorithm>"
+    },
+    "std::swap": {
+      "signature": "template<class T> void swap(T& a, T& b) noexcept(...)",
+      "description": "Exchanges the values of a and b. Uses move semantics when available.",
+      "type": "function",
+      "module": "<utility>"
+    },
+    "std::string_view": {
+      "signature": "using string_view = std::basic_string_view<char>",
+      "description": "A lightweight non-owning reference to a string or substring. Provides a read-only view without copying. Zero overhead. (C++17)",
+      "type": "class",
+      "module": "<string_view>",
+      "members": {
+        "size": { "signature": "constexpr size_type size() const noexcept", "description": "Returns the number of characters.", "type": "method" },
+        "empty": { "signature": "constexpr bool empty() const noexcept", "description": "Returns true if the view is empty.", "type": "method" },
+        "data": { "signature": "constexpr const char* data() const noexcept", "description": "Returns a pointer to the underlying character array.", "type": "method" },
+        "substr": { "signature": "constexpr string_view substr(size_type pos = 0, size_type count = npos) const", "description": "Returns a view of the substring.", "type": "method" },
+        "find": { "signature": "constexpr size_type find(string_view sv, size_type pos = 0) const noexcept", "description": "Finds the first occurrence of the given substring.", "type": "method" },
+        "starts_with": { "signature": "constexpr bool starts_with(string_view sv) const noexcept", "description": "Checks if the view starts with the given prefix (C++20).", "type": "method" },
+        "ends_with": { "signature": "constexpr bool ends_with(string_view sv) const noexcept", "description": "Checks if the view ends with the given suffix (C++20).", "type": "method" },
+        "remove_prefix": { "signature": "constexpr void remove_prefix(size_type n)", "description": "Shrinks the view by moving the start forward by n characters.", "type": "method" },
+        "remove_suffix": { "signature": "constexpr void remove_suffix(size_type n)", "description": "Shrinks the view by moving the end backward by n characters.", "type": "method" }
+      }
+    },
+    "std::variant": {
+      "signature": "template<class... Types> class variant",
+      "description": "Type-safe discriminated union. Holds a value of one of the specified alternative types at any given time. Never empty (unless valueless_by_exception). (C++17)",
+      "type": "class",
+      "module": "<variant>",
+      "members": {
+        "index": { "signature": "constexpr size_t index() const noexcept", "description": "Returns the zero-based index of the currently held alternative.", "type": "method" },
+        "valueless_by_exception": { "signature": "constexpr bool valueless_by_exception() const noexcept", "description": "Returns true if the variant is in an invalid state due to an exception.", "type": "method" },
+        "emplace": { "signature": "template<class T, class... Args> T& emplace(Args&&... args)", "description": "Constructs the given alternative type in-place.", "type": "method" },
+        "swap": { "signature": "void swap(variant& other) noexcept(...)", "description": "Swaps the contents with another variant.", "type": "method" }
+      }
+    },
+    "std::span": {
+      "signature": "template<class T, std::size_t Extent = std::dynamic_extent> class span",
+      "description": "A lightweight non-owning reference to a contiguous sequence of objects. Replacement for (pointer, length) pairs. (C++20)",
+      "type": "class",
+      "module": "<span>",
+      "members": {
+        "size": { "signature": "constexpr size_type size() const noexcept", "description": "Returns the number of elements in the span.", "type": "method" },
+        "data": { "signature": "constexpr pointer data() const noexcept", "description": "Returns a pointer to the beginning of the sequence.", "type": "method" },
+        "empty": { "signature": "constexpr bool empty() const noexcept", "description": "Returns true if the span has no elements.", "type": "method" },
+        "front": { "signature": "constexpr reference front() const", "description": "Returns the first element.", "type": "method" },
+        "back": { "signature": "constexpr reference back() const", "description": "Returns the last element.", "type": "method" },
+        "subspan": { "signature": "template<std::size_t Offset, std::size_t Count = dynamic_extent> constexpr span<T, ...> subspan() const", "description": "Returns a subspan starting at Offset.", "type": "method" },
+        "first": { "signature": "template<std::size_t Count> constexpr span<T, Count> first() const", "description": "Returns the first Count elements.", "type": "method" },
+        "last": { "signature": "template<std::size_t Count> constexpr span<T, Count> last() const", "description": "Returns the last Count elements.", "type": "method" }
+      }
+    }
+  }
+}

package/data/defination/csharp.json

@@ -0,0 +1,144 @@
+{
+  "language": "csharp",
+  "definitions": {
+    "String": {
+      "signature": "public sealed class String : IComparable, IEnumerable<char>, IEquatable<String>",
+      "description": "Represents text as a sequence of UTF-16 code units. Strings are immutable.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "Length": { "signature": "public int Length { get; }", "description": "Gets the number of characters in the current String object.", "type": "property" },
+        "Substring": { "signature": "public string Substring(int startIndex, int length)", "description": "Retrieves a substring from this instance starting at a specified character position and having a specified length.", "type": "method" },
+        "Contains": { "signature": "public bool Contains(string value, StringComparison comparisonType)", "description": "Returns a value indicating whether a specified substring occurs within this string, using the specified comparison rules.", "type": "method" },
+        "StartsWith": { "signature": "public bool StartsWith(string value, StringComparison comparisonType)", "description": "Determines whether the beginning of this string instance matches the specified string.", "type": "method" },
+        "EndsWith": { "signature": "public bool EndsWith(string value, StringComparison comparisonType)", "description": "Determines whether the end of this string instance matches the specified string.", "type": "method" },
+        "IndexOf": { "signature": "public int IndexOf(string value, StringComparison comparisonType)", "description": "Reports the zero-based index of the first occurrence of the specified string. Returns -1 if not found.", "type": "method" },
+        "LastIndexOf": { "signature": "public int LastIndexOf(string value, StringComparison comparisonType)", "description": "Reports the zero-based index position of the last occurrence of a specified string. Returns -1 if not found.", "type": "method" },
+        "Replace": { "signature": "public string Replace(string oldValue, string? newValue)", "description": "Returns a new string in which all occurrences of a specified string are replaced with another specified string.", "type": "method" },
+        "Split": { "signature": "public string[] Split(char separator, StringSplitOptions options = None)", "description": "Splits a string into substrings based on specified delimiting characters and options.", "type": "method" },
+        "Trim": { "signature": "public string Trim()", "description": "Removes all leading and trailing white-space characters from the current string.", "type": "method" },
+        "TrimStart": { "signature": "public string TrimStart()", "description": "Removes all leading white-space characters from the current string.", "type": "method" },
+        "TrimEnd": { "signature": "public string TrimEnd()", "description": "Removes all trailing white-space characters from the current string.", "type": "method" },
+        "ToUpper": { "signature": "public string ToUpper()", "description": "Returns a copy of this string converted to uppercase using the casing rules of the current culture.", "type": "method" },
+        "ToLower": { "signature": "public string ToLower()", "description": "Returns a copy of this string converted to lowercase using the casing rules of the current culture.", "type": "method" },
+        "PadLeft": { "signature": "public string PadLeft(int totalWidth, char paddingChar = ' ')", "description": "Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified character.", "type": "method" },
+        "PadRight": { "signature": "public string PadRight(int totalWidth, char paddingChar = ' ')", "description": "Returns a new string that left-aligns the characters in this string by padding them on the right with a specified character.", "type": "method" },
+        "Insert": { "signature": "public string Insert(int startIndex, string value)", "description": "Returns a new string in which a specified string is inserted at a specified index position in this instance.", "type": "method" },
+        "Remove": { "signature": "public string Remove(int startIndex, int count)", "description": "Returns a new string in which a specified number of characters beginning at a specified position have been deleted.", "type": "method" },
+        "Equals": { "signature": "public bool Equals(string? value, StringComparison comparisonType)", "description": "Determines whether this string and a specified String object have the same value, using the specified comparison rules.", "type": "method" },
+        "CompareTo": { "signature": "public int CompareTo(string? strB)", "description": "Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order.", "type": "method" },
+        "IsNullOrEmpty": { "signature": "public static bool IsNullOrEmpty(string? value)", "description": "Indicates whether the specified string is null or an empty string (\"\").", "type": "method" },
+        "IsNullOrWhiteSpace": { "signature": "public static bool IsNullOrWhiteSpace(string? value)", "description": "Indicates whether a specified string is null, empty, or consists only of white-space characters.", "type": "method" },
+        "Format": { "signature": "public static string Format(string format, params object?[] args)", "description": "Replaces one or more format items in a string with the string representation of a specified object.", "type": "method" },
+        "Join": { "signature": "public static string Join(string? separator, IEnumerable<string?> values)", "description": "Concatenates the members of a collection, using the specified separator between each member.", "type": "method" },
+        "Concat": { "signature": "public static string Concat(params string?[] values)", "description": "Concatenates one or more instances of String.", "type": "method" }
+      }
+    },
+    "List": {
+      "signature": "public class List<T> : IList<T>, IReadOnlyList<T>",
+      "description": "Represents a strongly typed list of objects that can be accessed by index. Provides methods to search, sort, and manipulate lists.",
+      "type": "class",
+      "module": "System.Collections.Generic",
+      "members": {
+        "Add": { "signature": "public void Add(T item)", "description": "Adds an object to the end of the List<T>.", "type": "method" },
+        "AddRange": { "signature": "public void AddRange(IEnumerable<T> collection)", "description": "Adds the elements of the specified collection to the end of the List<T>.", "type": "method" },
+        "Insert": { "signature": "public void Insert(int index, T item)", "description": "Inserts an element into the List<T> at the specified index.", "type": "method" },
+        "Remove": { "signature": "public bool Remove(T item)", "description": "Removes the first occurrence of a specific object from the List<T>. Returns true if the item was successfully removed.", "type": "method" },
+        "RemoveAt": { "signature": "public void RemoveAt(int index)", "description": "Removes the element at the specified index of the List<T>.", "type": "method" },
+        "RemoveAll": { "signature": "public int RemoveAll(Predicate<T> match)", "description": "Removes all the elements that match the conditions defined by the specified predicate. Returns the number of elements removed.", "type": "method" },
+        "Clear": { "signature": "public void Clear()", "description": "Removes all elements from the List<T>.", "type": "method" },
+        "Contains": { "signature": "public bool Contains(T item)", "description": "Determines whether an element is in the List<T>. Uses the default equality comparer.", "type": "method" },
+        "IndexOf": { "signature": "public int IndexOf(T item)", "description": "Searches for the specified object and returns the zero-based index of the first occurrence. Returns -1 if not found.", "type": "method" },
+        "Find": { "signature": "public T? Find(Predicate<T> match)", "description": "Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence.", "type": "method" },
+        "FindAll": { "signature": "public List<T> FindAll(Predicate<T> match)", "description": "Retrieves all the elements that match the conditions defined by the specified predicate.", "type": "method" },
+        "FindIndex": { "signature": "public int FindIndex(Predicate<T> match)", "description": "Searches for an element that matches the predicate and returns the zero-based index of the first occurrence. Returns -1 if not found.", "type": "method" },
+        "Sort": { "signature": "public void Sort(Comparison<T>? comparison)", "description": "Sorts the elements in the entire List<T> using the specified comparison.", "type": "method" },
+        "Reverse": { "signature": "public void Reverse()", "description": "Reverses the order of the elements in the entire List<T>.", "type": "method" },
+        "Count": { "signature": "public int Count { get; }", "description": "Gets the number of elements contained in the List<T>.", "type": "property" },
+        "ForEach": { "signature": "public void ForEach(Action<T> action)", "description": "Performs the specified action on each element of the List<T>.", "type": "method" },
+        "ToArray": { "signature": "public T[] ToArray()", "description": "Copies the elements of the List<T> to a new array.", "type": "method" },
+        "GetRange": { "signature": "public List<T> GetRange(int index, int count)", "description": "Creates a shallow copy of a range of elements in the source List<T>.", "type": "method" },
+        "BinarySearch": { "signature": "public int BinarySearch(T item)", "description": "Searches the entire sorted List<T> for an element using the default comparer and returns the zero-based index.", "type": "method" },
+        "Exists": { "signature": "public bool Exists(Predicate<T> match)", "description": "Determines whether the List<T> contains elements that match the conditions defined by the specified predicate.", "type": "method" },
+        "TrueForAll": { "signature": "public bool TrueForAll(Predicate<T> match)", "description": "Determines whether every element in the List<T> matches the conditions defined by the specified predicate.", "type": "method" },
+        "ConvertAll": { "signature": "public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter)", "description": "Converts the elements in the current List<T> to another type, and returns a list containing the converted elements.", "type": "method" }
+      }
+    },
+    "Dictionary": {
+      "signature": "public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue> where TKey : notnull",
+      "description": "Represents a collection of keys and values. Provides O(1) average-time complexity for lookups, insertions, and removals.",
+      "type": "class",
+      "module": "System.Collections.Generic",
+      "members": {
+        "Add": { "signature": "public void Add(TKey key, TValue value)", "description": "Adds the specified key and value to the dictionary. Throws ArgumentException if the key already exists.", "type": "method" },
+        "Remove": { "signature": "public bool Remove(TKey key)", "description": "Removes the value with the specified key from the dictionary. Returns true if the element was successfully found and removed.", "type": "method" },
+        "ContainsKey": { "signature": "public bool ContainsKey(TKey key)", "description": "Determines whether the Dictionary<TKey,TValue> contains the specified key.", "type": "method" },
+        "ContainsValue": { "signature": "public bool ContainsValue(TValue value)", "description": "Determines whether the Dictionary<TKey,TValue> contains a specific value. This is an O(n) operation.", "type": "method" },
+        "TryGetValue": { "signature": "public bool TryGetValue(TKey key, out TValue value)", "description": "Gets the value associated with the specified key. Returns true if the key was found.", "type": "method" },
+        "Keys": { "signature": "public Dictionary<TKey,TValue>.KeyCollection Keys { get; }", "description": "Gets a collection containing the keys in the dictionary.", "type": "property" },
+        "Values": { "signature": "public Dictionary<TKey,TValue>.ValueCollection Values { get; }", "description": "Gets a collection containing the values in the dictionary.", "type": "property" },
+        "Count": { "signature": "public int Count { get; }", "description": "Gets the number of key/value pairs contained in the dictionary.", "type": "property" },
+        "Clear": { "signature": "public void Clear()", "description": "Removes all keys and values from the dictionary.", "type": "method" },
+        "TryAdd": { "signature": "public bool TryAdd(TKey key, TValue value)", "description": "Attempts to add the specified key and value to the dictionary. Returns false if the key already exists (does not throw).", "type": "method" },
+        "GetValueOrDefault": { "signature": "public TValue GetValueOrDefault(TKey key, TValue defaultValue)", "description": "Gets the value associated with the specified key, or a default value if the key is not present.", "type": "method" }
+      }
+    },
+    "Task": {
+      "signature": "public class Task : IAsyncResult, IDisposable",
+      "description": "Represents an asynchronous operation. The Task class provides a way to schedule work and retrieve results or exceptions from asynchronous operations.",
+      "type": "class",
+      "module": "System.Threading.Tasks",
+      "members": {
+        "Run": { "signature": "public static Task Run(Action action)\npublic static Task<TResult> Run<TResult>(Func<TResult> function)", "description": "Queues the specified work to run on the ThreadPool and returns a Task or Task<TResult> representing that work.", "type": "method" },
+        "WhenAll": { "signature": "public static Task WhenAll(IEnumerable<Task> tasks)\npublic static Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>> tasks)", "description": "Creates a task that will complete when all of the supplied tasks have completed.", "type": "method" },
+        "WhenAny": { "signature": "public static Task<Task> WhenAny(IEnumerable<Task> tasks)", "description": "Creates a task that will complete when any of the supplied tasks have completed.", "type": "method" },
+        "Delay": { "signature": "public static Task Delay(int millisecondsDelay)\npublic static Task Delay(TimeSpan delay)", "description": "Creates a task that completes after a specified time interval.", "type": "method" },
+        "FromResult": { "signature": "public static Task<TResult> FromResult<TResult>(TResult result)", "description": "Creates a Task<TResult> that is completed successfully with the specified result.", "type": "method" },
+        "ContinueWith": { "signature": "public Task ContinueWith(Action<Task> continuationAction)", "description": "Creates a continuation that executes asynchronously when the target Task completes.", "type": "method" },
+        "ConfigureAwait": { "signature": "public ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)", "description": "Configures an awaiter used to await this Task. Set to false to avoid marshalling back to the original synchronization context.", "type": "method" },
+        "GetAwaiter": { "signature": "public TaskAwaiter GetAwaiter()", "description": "Gets an awaiter used to await this Task. Used by the compiler to implement the await keyword.", "type": "method" },
+        "Result": { "signature": "public TResult Result { get; }", "description": "Gets the result value of the Task<TResult>. Blocks the calling thread until the task completes if not already finished.", "type": "property" },
+        "IsCompleted": { "signature": "public bool IsCompleted { get; }", "description": "Gets whether this Task has completed (successfully, faulted, or canceled).", "type": "property" },
+        "IsFaulted": { "signature": "public bool IsFaulted { get; }", "description": "Gets whether the Task completed due to an unhandled exception.", "type": "property" },
+        "Exception": { "signature": "public AggregateException? Exception { get; }", "description": "Gets the AggregateException that caused the Task to end prematurely. Returns null if the Task completed successfully or was canceled.", "type": "property" }
+      }
+    },
+    "Enumerable": {
+      "signature": "public static class Enumerable",
+      "description": "Provides a set of static methods for querying objects that implement IEnumerable<T>. This is the core class for LINQ to Objects.",
+      "type": "class",
+      "module": "System.Linq",
+      "members": {
+        "Where": { "signature": "public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)", "description": "Filters a sequence of values based on a predicate.", "type": "method" },
+        "Select": { "signature": "public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)", "description": "Projects each element of a sequence into a new form.", "type": "method" },
+        "SelectMany": { "signature": "public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)", "description": "Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.", "type": "method" },
+        "OrderBy": { "signature": "public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)", "description": "Sorts the elements of a sequence in ascending order according to a key.", "type": "method" },
+        "OrderByDescending": { "signature": "public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)", "description": "Sorts the elements of a sequence in descending order according to a key.", "type": "method" },
+        "GroupBy": { "signature": "public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)", "description": "Groups the elements of a sequence according to a specified key selector function.", "type": "method" },
+        "First": { "signature": "public static TSource First<TSource>(this IEnumerable<TSource> source)", "description": "Returns the first element of a sequence. Throws InvalidOperationException if the sequence is empty.", "type": "method" },
+        "FirstOrDefault": { "signature": "public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source)", "description": "Returns the first element of a sequence, or a default value if the sequence contains no elements.", "type": "method" },
+        "Single": { "signature": "public static TSource Single<TSource>(this IEnumerable<TSource> source)", "description": "Returns the only element of a sequence. Throws if there is not exactly one element.", "type": "method" },
+        "SingleOrDefault": { "signature": "public static TSource? SingleOrDefault<TSource>(this IEnumerable<TSource> source)", "description": "Returns the only element, or a default value if the sequence is empty. Throws if more than one element.", "type": "method" },
+        "Any": { "signature": "public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)", "description": "Determines whether any element of a sequence satisfies a condition.", "type": "method" },
+        "All": { "signature": "public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)", "description": "Determines whether all elements of a sequence satisfy a condition.", "type": "method" },
+        "Count": { "signature": "public static int Count<TSource>(this IEnumerable<TSource> source)", "description": "Returns the number of elements in a sequence.", "type": "method" },
+        "Sum": { "signature": "public static int Sum(this IEnumerable<int> source)", "description": "Computes the sum of a sequence of numeric values.", "type": "method" },
+        "Min": { "signature": "public static TSource? Min<TSource>(this IEnumerable<TSource> source)", "description": "Returns the minimum value in a sequence.", "type": "method" },
+        "Max": { "signature": "public static TSource? Max<TSource>(this IEnumerable<TSource> source)", "description": "Returns the maximum value in a sequence.", "type": "method" },
+        "Average": { "signature": "public static double Average(this IEnumerable<int> source)", "description": "Computes the average of a sequence of numeric values.", "type": "method" },
+        "Aggregate": { "signature": "public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)", "description": "Applies an accumulator function over a sequence.", "type": "method" },
+        "Distinct": { "signature": "public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)", "description": "Returns distinct elements from a sequence by using the default equality comparer.", "type": "method" },
+        "Take": { "signature": "public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)", "description": "Returns a specified number of contiguous elements from the start of a sequence.", "type": "method" },
+        "Skip": { "signature": "public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)", "description": "Bypasses a specified number of elements in a sequence and then returns the remaining elements.", "type": "method" },
+        "ToList": { "signature": "public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)", "description": "Creates a List<T> from an IEnumerable<T>.", "type": "method" },
+        "ToArray": { "signature": "public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)", "description": "Creates an array from an IEnumerable<T>.", "type": "method" },
+        "ToDictionary": { "signature": "public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) where TKey : notnull", "description": "Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function.", "type": "method" },
+        "Range": { "signature": "public static IEnumerable<int> Range(int start, int count)", "description": "Generates a sequence of integral numbers within a specified range.", "type": "method" },
+        "Empty": { "signature": "public static IEnumerable<TResult> Empty<TResult>()", "description": "Returns an empty IEnumerable<T> that has the specified type argument.", "type": "method" },
+        "Repeat": { "signature": "public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)", "description": "Generates a sequence that contains one repeated value.", "type": "method" },
+        "Zip": { "signature": "public static IEnumerable<(TFirst, TSecond)> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second)", "description": "Produces a sequence of tuples with elements from the two specified sequences.", "type": "method" },
+        "Concat": { "signature": "public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)", "description": "Concatenates two sequences.", "type": "method" }
+      }
+    }
+  }
+}