Page Menu
Home
WickedGov Phorge
Search
Configure Global Search
Log In
Files
F7422423
Name.php
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Size
7 KB
Referenced Files
None
Subscribers
None
Name.php
View Options
<?php
declare
(
strict_types
=
1
);
namespace
PhpParser\Node
;
use
PhpParser\NodeAbstract
;
class
Name
extends
NodeAbstract
{
/**
* @var string[] Parts of the name
* @deprecated Use getParts() instead
*/
public
$parts
;
private
static
$specialClassNames
=
[
'self'
=>
true
,
'parent'
=>
true
,
'static'
=>
true
,
];
/**
* Constructs a name node.
*
* @param string|string[]|self $name Name as string, part array or Name instance (copy ctor)
* @param array $attributes Additional attributes
*/
public
function
__construct
(
$name
,
array
$attributes
=
[])
{
$this
->
attributes
=
$attributes
;
$this
->
parts
=
self
::
prepareName
(
$name
);
}
public
function
getSubNodeNames
()
:
array
{
return
[
'parts'
];
}
/**
* Get parts of name (split by the namespace separator).
*
* @return string[] Parts of name
*/
public
function
getParts
():
array
{
return
$this
->
parts
;
}
/**
* Gets the first part of the name, i.e. everything before the first namespace separator.
*
* @return string First part of the name
*/
public
function
getFirst
()
:
string
{
return
$this
->
parts
[
0
];
}
/**
* Gets the last part of the name, i.e. everything after the last namespace separator.
*
* @return string Last part of the name
*/
public
function
getLast
()
:
string
{
return
$this
->
parts
[
count
(
$this
->
parts
)
-
1
];
}
/**
* Checks whether the name is unqualified. (E.g. Name)
*
* @return bool Whether the name is unqualified
*/
public
function
isUnqualified
()
:
bool
{
return
1
===
count
(
$this
->
parts
);
}
/**
* Checks whether the name is qualified. (E.g. Name\Name)
*
* @return bool Whether the name is qualified
*/
public
function
isQualified
()
:
bool
{
return
1
<
count
(
$this
->
parts
);
}
/**
* Checks whether the name is fully qualified. (E.g. \Name)
*
* @return bool Whether the name is fully qualified
*/
public
function
isFullyQualified
()
:
bool
{
return
false
;
}
/**
* Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
*
* @return bool Whether the name is relative
*/
public
function
isRelative
()
:
bool
{
return
false
;
}
/**
* Returns a string representation of the name itself, without taking the name type into
* account (e.g., not including a leading backslash for fully qualified names).
*
* @return string String representation
*/
public
function
toString
()
:
string
{
return
implode
(
'
\\
'
,
$this
->
parts
);
}
/**
* Returns a string representation of the name as it would occur in code (e.g., including
* leading backslash for fully qualified names.
*
* @return string String representation
*/
public
function
toCodeString
()
:
string
{
return
$this
->
toString
();
}
/**
* Returns lowercased string representation of the name, without taking the name type into
* account (e.g., no leading backslash for fully qualified names).
*
* @return string Lowercased string representation
*/
public
function
toLowerString
()
:
string
{
return
strtolower
(
implode
(
'
\\
'
,
$this
->
parts
));
}
/**
* Checks whether the identifier is a special class name (self, parent or static).
*
* @return bool Whether identifier is a special class name
*/
public
function
isSpecialClassName
()
:
bool
{
return
count
(
$this
->
parts
)
===
1
&&
isset
(
self
::
$specialClassNames
[
strtolower
(
$this
->
parts
[
0
])]);
}
/**
* Returns a string representation of the name by imploding the namespace parts with the
* namespace separator.
*
* @return string String representation
*/
public
function
__toString
()
:
string
{
return
implode
(
'
\\
'
,
$this
->
parts
);
}
/**
* Gets a slice of a name (similar to array_slice).
*
* This method returns a new instance of the same type as the original and with the same
* attributes.
*
* If the slice is empty, null is returned. The null value will be correctly handled in
* concatenations using concat().
*
* Offset and length have the same meaning as in array_slice().
*
* @param int $offset Offset to start the slice at (may be negative)
* @param int|null $length Length of the slice (may be negative)
*
* @return static|null Sliced name
*/
public
function
slice
(
int
$offset
,
?
int
$length
=
null
)
{
$numParts
=
count
(
$this
->
parts
);
$realOffset
=
$offset
<
0
?
$offset
+
$numParts
:
$offset
;
if
(
$realOffset
<
0
||
$realOffset
>
$numParts
)
{
throw
new
\OutOfBoundsException
(
sprintf
(
'Offset %d is out of bounds'
,
$offset
));
}
if
(
null
===
$length
)
{
$realLength
=
$numParts
-
$realOffset
;
}
else
{
$realLength
=
$length
<
0
?
$length
+
$numParts
-
$realOffset
:
$length
;
if
(
$realLength
<
0
||
$realLength
>
$numParts
-
$realOffset
)
{
throw
new
\OutOfBoundsException
(
sprintf
(
'Length %d is out of bounds'
,
$length
));
}
}
if
(
$realLength
===
0
)
{
// Empty slice is represented as null
return
null
;
}
return
new
static
(
array_slice
(
$this
->
parts
,
$realOffset
,
$realLength
),
$this
->
attributes
);
}
/**
* Concatenate two names, yielding a new Name instance.
*
* The type of the generated instance depends on which class this method is called on, for
* example Name\FullyQualified::concat() will yield a Name\FullyQualified instance.
*
* If one of the arguments is null, a new instance of the other name will be returned. If both
* arguments are null, null will be returned. As such, writing
* Name::concat($namespace, $shortName)
* where $namespace is a Name node or null will work as expected.
*
* @param string|string[]|self|null $name1 The first name
* @param string|string[]|self|null $name2 The second name
* @param array $attributes Attributes to assign to concatenated name
*
* @return static|null Concatenated name
*/
public
static
function
concat
(
$name1
,
$name2
,
array
$attributes
=
[])
{
if
(
null
===
$name1
&&
null
===
$name2
)
{
return
null
;
}
elseif
(
null
===
$name1
)
{
return
new
static
(
self
::
prepareName
(
$name2
),
$attributes
);
}
elseif
(
null
===
$name2
)
{
return
new
static
(
self
::
prepareName
(
$name1
),
$attributes
);
}
else
{
return
new
static
(
array_merge
(
self
::
prepareName
(
$name1
),
self
::
prepareName
(
$name2
)),
$attributes
);
}
}
/**
* Prepares a (string, array or Name node) name for use in name changing methods by converting
* it to an array.
*
* @param string|string[]|self $name Name to prepare
*
* @return string[] Prepared name
*/
private
static
function
prepareName
(
$name
)
:
array
{
if
(
\is_string
(
$name
))
{
if
(
''
===
$name
)
{
throw
new
\InvalidArgumentException
(
'Name cannot be empty'
);
}
return
explode
(
'
\\
'
,
$name
);
}
elseif
(
\is_array
(
$name
))
{
if
(
empty
(
$name
))
{
throw
new
\InvalidArgumentException
(
'Name cannot be empty'
);
}
return
$name
;
}
elseif
(
$name
instanceof
self
)
{
return
$name
->
parts
;
}
throw
new
\InvalidArgumentException
(
'Expected string, array of parts or Name instance'
);
}
public
function
getType
()
:
string
{
return
'Name'
;
}
}
File Metadata
Details
Attached
Mime Type
text/x-php
Expires
Sun, Nov 22, 06:00 (15 h, 22 m ago)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
a3/0c/9cb75fb40337424c1bc219e21b09
Default Alt Text
Name.php (7 KB)
Attached To
Mode
rMWPROD MediaWiki Production
Attached
Detach File
Event Timeline
Log In to Comment