beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 00:50:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/AK/Forward.h

217 lines
4.4 KiB
C
Raw Normal View History

AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
*/
#pragma once
AK+Everywhere: Move custom deleter capability to OwnPtr `OwnPtrWithCustomDeleter` was a decorator which provided the ability to add a custom deleter to `OwnPtr` by wrapping and taking the deleter as a run-time argument to the constructor. This solution means that no additional space is needed for the `OwnPtr` because it doesn't need to store a pointer to the deleter, but comes at the cost of having an extra type that stores a pointer for every instance. This logic is moved directly into `OwnPtr` by adding a template argument that is defaulted to the default deleter for the type. This means that the type itself stores the pointer to the deleter instead of every instance and adds some type safety by encoding the deleter in the type itself instead of taking a run-time argument.
2022-12-16 03:51:55 +00:00
#include <AK/DefaultDelete.h>
AK: Combine SinglyLinkedList and SinglyLinkedListWithCount Using policy based design `SinglyLinkedList` and `SinglyLinkedListWithCount` can be combined into one class which takes a policy to determine how to keep track of the size of the list. The default policy is to use list iteration to count the items in the list each time. The `WithCount` form is a different policy which tracks the size, but comes with the overhead of storing the count and incrementing/decrementing on each modification. This model is extensible to have other forms of counting by implementing only a new policy instead of implementing a totally new type.
2022-12-18 01:06:29 +00:00
#include <AK/SinglyLinkedListSizePolicy.h>
AK: Use size_t for CircularQueue and CircularDeque
2020-02-20 12:18:42 +00:00
#include <AK/Types.h>
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
namespace AK {
AK: Turn ByteBuffer into a value type Previously ByteBuffer would internally hold a RefPtr to the byte buffer and would behave like a reference type, i.e. copying a ByteBuffer would not create a duplicate byte buffer, but rather two objects which refer to the same internal buffer. This also changes ByteBuffer so that it has some internal capacity much like the Vector<T> type. Unlike Vector<T> however a byte buffer's data may be uninitialized. With this commit ByteBuffer makes use of the kmalloc_good_size() API to pick an optimal allocation size for its internal buffer.
2021-05-14 18:53:04 +00:00
namespace Detail {
template<size_t inline_capacity>
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
class ByteBuffer;
AK: Turn ByteBuffer into a value type Previously ByteBuffer would internally hold a RefPtr to the byte buffer and would behave like a reference type, i.e. copying a ByteBuffer would not create a duplicate byte buffer, but rather two objects which refer to the same internal buffer. This also changes ByteBuffer so that it has some internal capacity much like the Vector<T> type. Unlike Vector<T> however a byte buffer's data may be uninitialized. With this commit ByteBuffer makes use of the kmalloc_good_size() API to pick an optimal allocation size for its internal buffer.
2021-05-14 18:53:04 +00:00
}
class Bitmap;
Everywhere: Remove unnecessary AK and Detail namespace scoping
2022-11-14 18:25:18 +00:00
using ByteBuffer = Detail::ByteBuffer<32>;
AK: Add `CircularBuffer` The class is very similar to `CircularDuplexStream` in its behavior. Main differences are that `CircularBuffer`: - does not inherit from `AK::Stream` - uses `ErrorOr` for its API - is heap allocated (and OOM-Safe) This patch also add some tests.
2022-12-08 21:44:46 +00:00
class CircularBuffer;
AK: Forward declare Error and ErrorOr in AK/Forward.h
2021-11-15 23:41:28 +00:00
class Error;
AK: Add GenericLexer to forwarding header
2021-08-18 11:22:38 +00:00
class GenericLexer;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
class IPv4Address;
class JsonArray;
class JsonObject;
class JsonValue;
LibJS+AK: Move cross-platform stack bounds code from JS::Heap to AK::StackInfo This will be useful for other things than the Heap, maybe even outside of LibJS.
2020-11-08 12:48:16 +00:00
class StackInfo;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
class DeprecatedString;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
class StringBuilder;
class StringImpl;
class StringView;
Kernel: Prevent using copy_from_user() for timespec/timeval These structs can be inconsistent, for example if the amount of microseconds is negative or larger than 1'000'000. Therefore, they should not be copied as-is. Use copy_time_from_user instead.
2021-02-13 10:33:28 +00:00
class Time;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
class URL;
AK: Add FlyString, a simple flyweight string class FlyString is a flyweight string class that wraps a RefPtr<StringImpl> known to be unique among the set of FlyStrings. The class is very unoptimized at the moment. When to use FlyString: - When you want O(1) string comparison - When you want to deduplicate a lot of identical strings When not to use FlyString: - For strings that don't need either of the above features - For strings that are likely to be unique
2020-03-22 09:12:55 +00:00
class FlyString;
AK: Introduce the new String, replacement for DeprecatedString DeprecatedString (formerly String) has been with us since the start, and it has served us well. However, it has a number of shortcomings that I'd like to address. Some of these issues are hard if not impossible to solve incrementally inside of DeprecatedString, so instead of doing that, let's build a new String class and then incrementally move over to it instead. Problems in DeprecatedString: - It assumes string allocation never fails. This makes it impossible to use in allocation-sensitive contexts, and is the reason we had to ban DeprecatedString from the kernel entirely. - The awkward null state. DeprecatedString can be null. It's different from the empty state, although null strings are considered empty. All code is immediately nicer when using Optional<DeprecatedString> but DeprecatedString came before Optional, which is how we ended up like this. - The encoding of the underlying data is ambiguous. For the most part, we use it as if it's always UTF-8, but there have been cases where we pass around strings in other encodings (e.g ISO8859-1) - operator[] and length() are used to iterate over DeprecatedString one byte at a time. This is done all over the codebase, and will *not* give the right results unless the string is all ASCII. How we solve these issues in the new String: - Functions that may allocate now return ErrorOr<String> so that ENOMEM errors can be passed to the caller. - String has no null state. Use Optional<String> when needed. - String is always UTF-8. This is validated when constructing a String. We may need to add a bypass for this in the future, for cases where you have a known-good string, but for now: validate all the things! - There is no operator[] or length(). You can get the underlying data with bytes(), but for iterating over code points, you should be using an UTF-8 iterator. Furthermore, it has two nifty new features: - String implements a small string optimization (SSO) for strings that can fit entirely within a pointer. This means up to 3 bytes on 32-bit platforms, and 7 bytes on 64-bit platforms. Such small strings will not be heap-allocated. - String can create substrings without making a deep copy of the substring. Instead, the superstring gets +1 refcount from the substring, and it acts like a view into the superstring. To make substrings like this, use the substring_with_shared_superstring() API. One caveat: - String does not guarantee that the underlying data is null-terminated like DeprecatedString does today. While this was nifty in a handful of places where we were calling C functions, it did stand in the way of shared-superstring substrings.
2022-12-01 12:27:43 +00:00
class String;
AK: Add Utf16View for decoding UTF-16 strings Also includes a way to transcode from and to UTF-8 strings.
2021-07-19 13:02:13 +00:00
class Utf16View;
AK: Add a very basic Utf32View class This allows you to wrap a { const u32* codepoints, size_t length } in a simple object.
2020-05-17 18:01:45 +00:00
class Utf32View;
AK: Add forward declaration for Utf8CodePointIterator
2022-02-23 20:05:27 +00:00
class Utf8CodePointIterator;
AK: Add Utf8View to Forward.h
2020-02-14 22:28:34 +00:00
class Utf8View;
AK: Add InputStream abstraction and InputMemoryStream implementation.
2020-08-05 10:14:44 +00:00
class InputStream;
class InputMemoryStream;
AK: Add DuplexMemoryStream class. This class is similar to BufferStream because it is possible to both read and write to it. However, it differs in the following ways: - DuplexMemoryStream keeps a history of 64KiB and discards the rest, BufferStream always keeps everything around. - DuplexMemoryStream tracks reading and writing seperately, the following is valid: DuplexMemoryStream stream; stream << 42; int value; stream >> value; For BufferStream it would read: BufferStream stream; stream << 42; int value; stream.seek(0); stream >> value; In the future I would like to replace all usages of BufferStream with InputMemoryStream, OutputMemoryStream (doesn't exist yet) and DuplexMemoryStream. For now I just add DuplexMemoryStream though.
2020-08-18 16:04:17 +00:00
class DuplexMemoryStream;
AK: Add CircularDuplexStream class.
2020-08-25 12:57:02 +00:00
class OutputStream;
AK: Add InputBitStream class.
2020-08-25 13:19:55 +00:00
class InputBitStream;
AK: Add OutputBitStream class This will be used in the deflate compressor.
2021-03-01 15:43:54 +00:00
class OutputBitStream;
AK: Re-add OutputMemoryStream for static buffers only.
2020-09-15 10:08:00 +00:00
class OutputMemoryStream;
AK: Add CircularDuplexStream class.
2020-08-25 12:57:02 +00:00
template<size_t Capacity>
class CircularDuplexStream;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
AK: Implement Span which represents a contiguous sequence of objects. This makes it possible to pass one object rather than pointer and length individually.
2020-07-25 14:00:26 +00:00
template<typename T>
class Span;
AK: Add Array<T, Size> template.
2020-09-06 19:13:34 +00:00
template<typename T, size_t Size>
AK: Fix forward-declaration of Array
2020-09-11 22:43:11 +00:00
struct Array;
AK: Add generic SimpleIterator class to replace VectorIterator.
2020-09-06 19:14:08 +00:00
template<typename Container, typename ValueType>
class SimpleIterator;
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
using ReadonlyBytes = Span<u8 const>;
AK: Implement Span which represents a contiguous sequence of objects. This makes it possible to pass one object rather than pointer and length individually.
2020-07-25 14:00:26 +00:00
using Bytes = Span<u8>;
AK: Add default memory order as template argument for Atomic<T> This is useful for collecting statistics, e.g. Atomic<unsigned, MemoryOrder::memory_order_relaxed> would allow using operators such as ++ to use relaxed semantics throughout without having to explicitly call fetch_add with the memory order.
2021-01-03 23:43:10 +00:00
template<typename T, AK::MemoryOrder DefaultMemoryOrder>
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
class Atomic;
AK: Combine SinglyLinkedList and SinglyLinkedListWithCount Using policy based design `SinglyLinkedList` and `SinglyLinkedListWithCount` can be combined into one class which takes a policy to determine how to keep track of the size of the list. The default policy is to use list iteration to count the items in the list each time. The `WithCount` form is a different policy which tracks the size, but comes with the overhead of storing the count and incrementing/decrementing on each modification. This model is extensible to have other forms of counting by implementing only a new policy instead of implementing a totally new type.
2022-12-18 01:06:29 +00:00
template<typename T, typename TSizeCalculationPolicy = DefaultSizeCalculationPolicy>
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
class SinglyLinkedList;
template<typename T>
class DoublyLinkedList;
AK: Use size_t for CircularQueue and CircularDeque
2020-02-20 12:18:42 +00:00
template<typename T, size_t capacity>
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
class CircularQueue;
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
template<typename T>
struct Traits;
AK: Add Ordering support to HashTable and HashMap Adds a IsOrdered flag to Hashtable and HashMap, which allows iteration in insertion order
2021-06-13 14:26:08 +00:00
template<typename T, typename TraitsForT = Traits<T>, bool IsOrdered = false>
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
class HashTable;
AK: Add Ordering support to HashTable and HashMap Adds a IsOrdered flag to Hashtable and HashMap, which allows iteration in insertion order
2021-06-13 14:26:08 +00:00
template<typename T, typename TraitsForT = Traits<T>>
using OrderedHashTable = HashTable<T, TraitsForT, true>;
AK: Let HashMap also take a ValueTraits We were previously using Traits<V>, take that frrom the template parameters instead. This is needed by the Jakt runtime.
2022-12-09 16:39:56 +00:00
template<typename K, typename V, typename KeyTraits = Traits<K>, typename ValueTraits = Traits<V>, bool IsOrdered = false>
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
class HashMap;
AK: Let HashMap also take a ValueTraits We were previously using Traits<V>, take that frrom the template parameters instead. This is needed by the Jakt runtime.
2022-12-09 16:39:56 +00:00
template<typename K, typename V, typename KeyTraits = Traits<K>, typename ValueTraits = Traits<V>>
using OrderedHashMap = HashMap<K, V, KeyTraits, ValueTraits, true>;
AK: Add Ordering support to HashTable and HashMap Adds a IsOrdered flag to Hashtable and HashMap, which allows iteration in insertion order
2021-06-13 14:26:08 +00:00
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
template<typename T>
class Badge;
AK: Bring back FixedArray<T> Let's bring this class back, but without the confusing resize() API. A FixedArray<T> is simply a fixed-size array of T. The size is provided at run-time, unlike Array<T> where the size is provided at compile-time.
2021-07-11 15:16:13 +00:00
template<typename T>
class FixedArray;
AK: Loosen FixedPoint template contraints and forward-declare it Because AK/Concepts.h includes AK/Forward.h and concepts cannot be forward declared, slightly losen the FixedPoint template arguments so that we can forward declare it in AK/Forward.h
2021-12-28 01:18:53 +00:00
template<size_t precision, typename Underlying = i32>
class FixedPoint;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
template<typename>
class Function;
template<typename Out, typename... In>
class Function<Out(In...)>;
template<typename T>
class NonnullRefPtr;
template<typename T>
class NonnullOwnPtr;
AK: Make Nonnull*PtrVector use size_t for indexes This was weird. It turns out these class were using int indexes and sizes despite being derived from Vector which uses size_t. Make the universe right again by using size_t here as well.
2021-02-20 16:39:58 +00:00
template<typename T, size_t inline_capacity = 0>
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
class NonnullOwnPtrVector;
AK: Forward declare Nonnull{Own,Ref}PtrVector
2020-12-01 23:19:30 +00:00
AK: Make Nonnull*PtrVector use size_t for indexes This was weird. It turns out these class were using int indexes and sizes despite being derived from Vector which uses size_t. Make the universe right again by using size_t here as well.
2021-02-20 16:39:58 +00:00
template<typename T, size_t inline_capacity = 0>
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
class NonnullRefPtrVector;
AK: Forward declare Nonnull{Own,Ref}PtrVector
2020-12-01 23:19:30 +00:00
LibCore: Add a forward declaration header This patch adds <LibCore/Forward.h> and uses it in various places to shrink the header dependency graph.
2020-02-14 21:29:06 +00:00
template<typename T>
class Optional;
AK+Kernel: Remove RefPtrTraits template param in userspace code Only the kernel actually uses RefPtrTraits, so let's not burden userspace builds with the complexity.
2022-05-07 10:50:54 +00:00
#ifdef KERNEL
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
template<typename T>
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
class NonnullLockRefPtr;
template<typename T, size_t inline_capacity = 0>
class NonnullLockRefPtrVector;
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
AK+Kernel: Remove RefPtrTraits template param in userspace code Only the kernel actually uses RefPtrTraits, so let's not burden userspace builds with the complexity.
2022-05-07 10:50:54 +00:00
template<typename T>
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
struct LockRefPtrTraits;
template<typename T, typename PtrTraits = LockRefPtrTraits<T>>
class LockRefPtr;
AK+Kernel: Remove RefPtrTraits template param in userspace code Only the kernel actually uses RefPtrTraits, so let's not burden userspace builds with the complexity.
2022-05-07 10:50:54 +00:00
#endif
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
template<typename T>
class RefPtr;
AK+Everywhere: Move custom deleter capability to OwnPtr `OwnPtrWithCustomDeleter` was a decorator which provided the ability to add a custom deleter to `OwnPtr` by wrapping and taking the deleter as a run-time argument to the constructor. This solution means that no additional space is needed for the `OwnPtr` because it doesn't need to store a pointer to the deleter, but comes at the cost of having an extra type that stores a pointer for every instance. This logic is moved directly into `OwnPtr` by adding a template argument that is defaulted to the default deleter for the type. This means that the type itself stores the pointer to the deleter instead of every instance and adds some type safety by encoding the deleter in the type itself instead of taking a run-time argument.
2022-12-16 03:51:55 +00:00
template<typename T, typename TDeleter = DefaultDelete<T>>
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
class OwnPtr;
template<typename T>
class WeakPtr;
AK: Make Vector use size_t for its size and capacity
2020-02-25 13:49:47 +00:00
template<typename T, size_t inline_capacity = 0>
AK: Make Vector capable of holding reference types This commit makes it possible to instantiate `Vector<T&>` and use it to store references to `T` in a vector. All non-pointer observers are made to return the reference, and the pointer observers simply yield the underlying pointer. Note that the 'find_*' methods act on the values and not the pointers that are stored in the vector. This commit also makes errors in various vector methods much more readable by directly using requires-clauses on them. And finally, it should be noted that Vector cannot hold temporaries :^)
2021-06-08 13:24:06 +00:00
requires(!IsRvalueReference<T>) class Vector;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
AK: Forward declare Error and ErrorOr in AK/Forward.h
2021-11-15 23:41:28 +00:00
template<typename T, typename ErrorType = Error>
class [[nodiscard]] ErrorOr;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
}
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#if USING_AK_GLOBALLY
AK: Add generic SimpleIterator class to replace VectorIterator.
2020-09-06 19:14:08 +00:00
using AK::Array;
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
using AK::Atomic;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::Badge;
using AK::Bitmap;
using AK::ByteBuffer;
AK: Implement Span which represents a contiguous sequence of objects. This makes it possible to pass one object rather than pointer and length individually.
2020-07-25 14:00:26 +00:00
using AK::Bytes;
AK: Add `CircularBuffer` The class is very similar to `CircularDuplexStream` in its behavior. Main differences are that `CircularBuffer`: - does not inherit from `AK::Stream` - uses `ErrorOr` for its API - is heap allocated (and OOM-Safe) This patch also add some tests.
2022-12-08 21:44:46 +00:00
using AK::CircularBuffer;
AK: Add CircularDuplexStream class.
2020-08-25 12:57:02 +00:00
using AK::CircularDuplexStream;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::CircularQueue;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
using AK::DeprecatedString;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::DoublyLinkedList;
AK: Add DuplexMemoryStream class. This class is similar to BufferStream because it is possible to both read and write to it. However, it differs in the following ways: - DuplexMemoryStream keeps a history of 64KiB and discards the rest, BufferStream always keeps everything around. - DuplexMemoryStream tracks reading and writing seperately, the following is valid: DuplexMemoryStream stream; stream << 42; int value; stream >> value; For BufferStream it would read: BufferStream stream; stream << 42; int value; stream.seek(0); stream >> value; In the future I would like to replace all usages of BufferStream with InputMemoryStream, OutputMemoryStream (doesn't exist yet) and DuplexMemoryStream. For now I just add DuplexMemoryStream though.
2020-08-18 16:04:17 +00:00
using AK::DuplexMemoryStream;
AK: Forward declare Error and ErrorOr in AK/Forward.h
2021-11-15 23:41:28 +00:00
using AK::Error;
using AK::ErrorOr;
AK: Bring back FixedArray<T> Let's bring this class back, but without the confusing resize() API. A FixedArray<T> is simply a fixed-size array of T. The size is provided at run-time, unlike Array<T> where the size is provided at compile-time.
2021-07-11 15:16:13 +00:00
using AK::FixedArray;
AK: Loosen FixedPoint template contraints and forward-declare it Because AK/Concepts.h includes AK/Forward.h and concepts cannot be forward declared, slightly losen the FixedPoint template arguments so that we can forward declare it in AK/Forward.h
2021-12-28 01:18:53 +00:00
using AK::FixedPoint;
AK: Add a very basic Utf32View class This allows you to wrap a { const u32* codepoints, size_t length } in a simple object.
2020-05-17 18:01:45 +00:00
using AK::FlyString;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::Function;
AK: Add GenericLexer to forwarding header
2021-08-18 11:22:38 +00:00
using AK::GenericLexer;
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
using AK::HashMap;
using AK::HashTable;
AK: Add InputBitStream class.
2020-08-25 13:19:55 +00:00
using AK::InputBitStream;
AK: Add InputStream abstraction and InputMemoryStream implementation.
2020-08-05 10:14:44 +00:00
using AK::InputMemoryStream;
using AK::InputStream;
AK: Use size_t for CircularQueue and CircularDeque
2020-02-20 12:18:42 +00:00
using AK::IPv4Address;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::JsonArray;
using AK::JsonObject;
using AK::JsonValue;
using AK::NonnullOwnPtr;
AK: Forward declare Nonnull{Own,Ref}PtrVector
2020-12-01 23:19:30 +00:00
using AK::NonnullOwnPtrVector;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::NonnullRefPtr;
AK: Forward declare Nonnull{Own,Ref}PtrVector
2020-12-01 23:19:30 +00:00
using AK::NonnullRefPtrVector;
LibCore: Add a forward declaration header This patch adds <LibCore/Forward.h> and uses it in various places to shrink the header dependency graph.
2020-02-14 21:29:06 +00:00
using AK::Optional;
AK: Add OutputBitStream class This will be used in the deflate compressor.
2021-03-01 15:43:54 +00:00
using AK::OutputBitStream;
AK: Re-add OutputMemoryStream for static buffers only.
2020-09-15 10:08:00 +00:00
using AK::OutputMemoryStream;
AK: Add CircularDuplexStream class.
2020-08-25 12:57:02 +00:00
using AK::OutputStream;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::OwnPtr;
AK: Implement Span which represents a contiguous sequence of objects. This makes it possible to pass one object rather than pointer and length individually.
2020-07-25 14:00:26 +00:00
using AK::ReadonlyBytes;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::RefPtr;
using AK::SinglyLinkedList;
AK: Implement Span which represents a contiguous sequence of objects. This makes it possible to pass one object rather than pointer and length individually.
2020-07-25 14:00:26 +00:00
using AK::Span;
LibJS+AK: Move cross-platform stack bounds code from JS::Heap to AK::StackInfo This will be useful for other things than the Heap, maybe even outside of LibJS.
2020-11-08 12:48:16 +00:00
using AK::StackInfo;
AK: Introduce the new String, replacement for DeprecatedString DeprecatedString (formerly String) has been with us since the start, and it has served us well. However, it has a number of shortcomings that I'd like to address. Some of these issues are hard if not impossible to solve incrementally inside of DeprecatedString, so instead of doing that, let's build a new String class and then incrementally move over to it instead. Problems in DeprecatedString: - It assumes string allocation never fails. This makes it impossible to use in allocation-sensitive contexts, and is the reason we had to ban DeprecatedString from the kernel entirely. - The awkward null state. DeprecatedString can be null. It's different from the empty state, although null strings are considered empty. All code is immediately nicer when using Optional<DeprecatedString> but DeprecatedString came before Optional, which is how we ended up like this. - The encoding of the underlying data is ambiguous. For the most part, we use it as if it's always UTF-8, but there have been cases where we pass around strings in other encodings (e.g ISO8859-1) - operator[] and length() are used to iterate over DeprecatedString one byte at a time. This is done all over the codebase, and will *not* give the right results unless the string is all ASCII. How we solve these issues in the new String: - Functions that may allocate now return ErrorOr<String> so that ENOMEM errors can be passed to the caller. - String has no null state. Use Optional<String> when needed. - String is always UTF-8. This is validated when constructing a String. We may need to add a bypass for this in the future, for cases where you have a known-good string, but for now: validate all the things! - There is no operator[] or length(). You can get the underlying data with bytes(), but for iterating over code points, you should be using an UTF-8 iterator. Furthermore, it has two nifty new features: - String implements a small string optimization (SSO) for strings that can fit entirely within a pointer. This means up to 3 bytes on 32-bit platforms, and 7 bytes on 64-bit platforms. Such small strings will not be heap-allocated. - String can create substrings without making a deep copy of the substring. Instead, the superstring gets +1 refcount from the substring, and it acts like a view into the superstring. To make substrings like this, use the substring_with_shared_superstring() API. One caveat: - String does not guarantee that the underlying data is null-terminated like DeprecatedString does today. While this was nifty in a handful of places where we were calling C functions, it did stand in the way of shared-superstring substrings.
2022-12-01 12:27:43 +00:00
using AK::String;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::StringBuilder;
using AK::StringImpl;
using AK::StringView;
Kernel: Prevent using copy_from_user() for timespec/timeval These structs can be inconsistent, for example if the amount of microseconds is negative or larger than 1'000'000. Therefore, they should not be copied as-is. Use copy_time_from_user instead.
2021-02-13 10:33:28 +00:00
using AK::Time;
AK: Add HashMap, HashTable and Traits to Forward.h
2020-02-16 01:01:18 +00:00
using AK::Traits;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::URL;
AK: Add Utf16View for decoding UTF-16 strings Also includes a way to transcode from and to UTF-8 strings.
2021-07-19 13:02:13 +00:00
using AK::Utf16View;
AK: Add a very basic Utf32View class This allows you to wrap a { const u32* codepoints, size_t length } in a simple object.
2020-05-17 18:01:45 +00:00
using AK::Utf32View;
AK: Add forward declaration for Utf8CodePointIterator
2022-02-23 20:05:27 +00:00
using AK::Utf8CodePointIterator;
AK: Add Utf8View to Forward.h
2020-02-14 22:28:34 +00:00
using AK::Utf8View;
AK: Add a forward declaration header You can now #include <AK/Forward.h> to get most of the AK types as forward declarations. Header dependency explosion is one of the main contributors to compile times at the moment, so this is a step towards smaller include graphs.
2020-02-14 20:41:10 +00:00
using AK::Vector;
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
# ifdef KERNEL
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
using AK::LockRefPtr;
using AK::LockRefPtrTraits;
using AK::NonnullLockRefPtr;
using AK::NonnullLockRefPtrVector;
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
# endif
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
#endif
Reference in a new issue Copy permalink