vlw/functionflags
1
0
Fork 0
mirror of https://codeberg.org/vlw/functionflags.git synced 2025-09-14 11:23:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: vlw:master
Branches Tags
vlw:master
vlw:1.1.0
vlw:1.0.3
vlw:1.0.2
vlw:1.0.1
vlw:1.0.0
..
compare: vlw:1.0.2
Branches Tags
vlw:master
vlw:1.1.0
vlw:1.0.3
vlw:1.0.2
vlw:1.0.1
vlw:1.0.0

No commits in common. "master" and "1.0.2" have entirely different histories.
master ... 1.0.2

2 changed files with 26 additions and 123 deletions
Show stats Expand all files Collapse all files

14
README.md
View file

@ -27,17 +27,17 @@ Flags can also be scoped to a class by creating a new `FunctionFlags` instance.
```php
use FunctionFlags/FunctionFlags
$flags1 = new FunctionFlags(["FOO", "BAR"]);
$flags2 = new FunctionFlags(["BAR", "BIZ"]);
$my_flag = new FunctionFlags("MY_FLAG");
$other_flag = new FunctionFlags("OTHER_FLAG");
// Returns true if FOO is passed and present in $flags1
// Returns true if MY_FLAG is passed and present in $my_flag
function foo(int $flags = null): bool {
return $flags2->isset(FOO);
return $my_flag->isset(MY_FLAG);
}
foo(FOO); // true
foo(FOO|BIZ); // true
foo(BIZ); // false
foo(MY_FLAG); // true
foo(OTHER_FLAG|MY_FLAG); // true
foo(OTHER_FLAG); // false
foo(); // false
```

131
src/FunctionFlags.php
View file

@ -3,69 +3,14 @@
namespace FunctionFlags;
class FunctionFlags {
// Limit debug_backtrace() to this amout of stack entries when trying to locate the
// first occurance of this class. Set to 0 for unlimited.
public static $BACKTRACE_LIMIT = 5;
// Methods by name that can be called statically
private static $static_public_whitelist = [
"static_define",
"static_isset"
];
// Methods by name that can be called when instanced
private static $inst_public_whitelist = [
"inst_define",
"inst_isset"
];
public function __construct(string|array $flags = null) {
// This array will contain instance defined flags
$this->flags = [];
// Define flags that were initialized with this class
if (!empty($flags)) {
$this->inst_define($flags);
}
}
// We're using the PHP __call() and __callStatic() magic functions here in order to allow
// methods to be called with the same name downstream. inst_define() and static_define() can
// be called using FunctionFlags::define() and FunctionFlags->define().
// Call static method on this class
public static function __callStatic(string $method, array $args): mixed {
// Static methods use this method prefix
$method_prefixed = "static_" . $method;
// Check that method exists on this class and is in whitelist of public static methods
if (!in_array($method_prefixed, get_class_methods(__CLASS__)) && !in_array($method_prefixed, (__CLASS__)::$static_public_whitelist)) {
throw new \BadMethodCallException("Method '${method}' does not exist");
}
return (__CLASS__)::{$method_prefixed}(...$args);
}
// Call instanced method on this class
public function __call(string $method, array $args): mixed {
// Instanced methods use this method prefix
$method_prefixed = "inst_" . $method;
// Check that method exists on this class and is in whitelist of public instanced methods
if (!in_array($method_prefixed, get_class_methods(__CLASS__)) && !in_array($method_prefixed, (__CLASS__)::$inst_public_whitelist)) {
throw new \BadMethodCallException("Method '${method}' does not exist");
}
return $this->{$method_prefixed}(...$args);
}
/* ---- */
// Limit value for debug_backtrace()
private static $trace_limit = 5;
// Reserve a constant address space
private static function addr_reserve(): int {
// Set initial value when first flag is defined
if (empty($_ENV[__CLASS__])) {
$_ENV[__CLASS__] = 1;
$_ENV[__CLASS__] = 0;
}
// Increment counter
@ -76,80 +21,38 @@
// Get flags from caller closest to this method on the call stack
private static function get_flags_from_caller(): int|null {
// Get call stack in reverse order
$stack = array_reverse(debug_backtrace(0, (__CLASS__)::$BACKTRACE_LIMIT));
// Get call stack
$stack = debug_backtrace(0, (__CLASS__)::$trace_limit);
// Find first occurance of this class name in call stack
$idx = array_search(__CLASS__, array_column($stack, "class"));
// Failed to locate this class
// Extract class names from callstack in reverse order and find the first occurance of this class in the backtrace
$idx = array_search(__CLASS__, array_reverse(array_column($stack, "class")));
// Failed to locate this class in a full backtrace
if ($idx === false) {
throw new Exception("Failed to retrieve flags from initator callable; Perhaps increase FunctionFlags::\$BACKTRACE_LIMIT");
} elseif ($idx === 0) {
// No parent callable. Method was probably called on its own
return null;
throw new Exception("Failed to retrieve flags from initator callable");
}
// Get args array from initial caller by simply stepping back one entry in the reverse array
$args = $stack[$idx - 1]["args"];
// Get args array from stack entry by index
$args = $stack[$idx]["args"];
// Return null if no arguments provided or not a valid int flag
return !empty($args) && is_int(end($args)) ? end($args) : null;
return !empty($args) ? end($args) : null;
}
/* ---- */
// Define new constants
private static function static_define(string|array $flags): array {
public static function define(string|array $flags) {
// Convert to array
$flags = is_array($flags) ? $flags : [$flags];
$reserved = [];
// Define constant for each flag with unique address
foreach ($flags as $flag) {
// Constant already defined with that name
if (defined($flag)) {
// Pass existing address
$reserved[] = constant($flag);
continue;
define($flag, (__CLASS__)::addr_reserve());
}
// Reserve new address
$addr = (__CLASS__)::addr_reserve();
$reserved[] = $addr;
define($flag, $addr);
}
// Return reserved addresses
return $reserved;
}
// Check if a flag is set with bitwise AND of all flags
private static function static_isset(int $flag): bool {
$flags = (__CLASS__)::get_flags_from_caller();
return $flags ? $flags & $flag : false;
}
/* ---- */
// Define flag(s) for $this instance
private function inst_define(string|array $flags) {
// Convert to array
$flags = is_array($flags) ? $flags : [$flags];
// Append flag(s) to instance memory
$this->flags = array_merge($this->flags, $this::static_define($flags));
}
// Check if flag is set and within $this scope
private function inst_isset(int $flag): bool {
// Return false if the flag is not in scope of $this instance
if (!in_array($flag, $this->flags)) {
return false;
}
// Filter flags that belong to this scope
return $this::static_isset($flag);
public static function isset(int $flag): bool|null {
$flags = FunctionFlags::get_flags_from_caller();
return $flags ? $flags & $flag : null;
}
}