#[repr(transparent)]
pub struct DebugFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for DebugFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> Debug for DebugFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> DebugFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DebugFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for DebugFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> Debug for DebugFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> DebugFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DebugFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for DebugFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> Debug for DebugFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> DebugFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DebugFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for DebugFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> Debug for DebugFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> DebugFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DebugFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for DebugFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> Debug for DebugFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> DebugFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DebugFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for DebugFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> Debug for DebugFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> DebugFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DebugFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for DebugFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> Debug for DebugFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> DebugFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for DisplayFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> Display for DisplayFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> DisplayFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for DisplayFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> Display for DisplayFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> DisplayFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for DisplayFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> Display for DisplayFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> DisplayFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for DisplayFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> Display for DisplayFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> DisplayFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for DisplayFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> Display for DisplayFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> DisplayFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for DisplayFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> Display for DisplayFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> DisplayFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct DisplayFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for DisplayFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> Display for DisplayFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> DisplayFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for LowerExpFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> LowerExp for LowerExpFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> LowerExpFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for LowerExpFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> LowerExp for LowerExpFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> LowerExpFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for LowerExpFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> LowerExp for LowerExpFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> LowerExpFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for LowerExpFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> LowerExp for LowerExpFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> LowerExpFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for LowerExpFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> LowerExp for LowerExpFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> LowerExpFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for LowerExpFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> LowerExp for LowerExpFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> LowerExpFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerExpFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for LowerExpFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> LowerExp for LowerExpFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> LowerExpFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for LowerHexFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> LowerHex for LowerHexFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> LowerHexFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for LowerHexFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> LowerHex for LowerHexFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> LowerHexFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for LowerHexFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> LowerHex for LowerHexFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> LowerHexFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for LowerHexFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> LowerHex for LowerHexFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> LowerHexFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for LowerHexFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> LowerHex for LowerHexFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> LowerHexFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for LowerHexFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> LowerHex for LowerHexFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> LowerHexFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct LowerHexFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for LowerHexFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> LowerHex for LowerHexFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> LowerHexFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for OctalFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> Octal for OctalFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> OctalFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for OctalFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> Octal for OctalFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> OctalFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for OctalFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> Octal for OctalFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> OctalFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for OctalFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> Octal for OctalFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> OctalFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for OctalFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> Octal for OctalFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> OctalFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for OctalFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> Octal for OctalFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> OctalFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct OctalFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for OctalFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> Octal for OctalFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> OctalFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for PointerFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> Pointer for PointerFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> PointerFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for PointerFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> Pointer for PointerFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> PointerFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for PointerFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> Pointer for PointerFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> PointerFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for PointerFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> Pointer for PointerFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> PointerFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for PointerFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> Pointer for PointerFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> PointerFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for PointerFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> Pointer for PointerFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> PointerFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct PointerFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for PointerFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> Pointer for PointerFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> PointerFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for UpperExpFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> UpperExp for UpperExpFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> UpperExpFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for UpperExpFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> UpperExp for UpperExpFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> UpperExpFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for UpperExpFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> UpperExp for UpperExpFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> UpperExpFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for UpperExpFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> UpperExp for UpperExpFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> UpperExpFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for UpperExpFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> UpperExp for UpperExpFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> UpperExpFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for UpperExpFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> UpperExp for UpperExpFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> UpperExpFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperExpFromUpperHex<T: UpperHex> (pub T);
impl<T: UpperHex> From<T> for UpperExpFromUpperHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperHex> UpperExp for UpperExpFromUpperHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperHex::fmt(&self.0, f)
}
}
impl<T: UpperHex> UpperExpFromUpperHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromDebug<T: Debug> (pub T);
impl<T: Debug> From<T> for UpperHexFromDebug<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Debug> UpperHex for UpperHexFromDebug<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl<T: Debug> UpperHexFromDebug<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromDisplay<T: Display> (pub T);
impl<T: Display> From<T> for UpperHexFromDisplay<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Display> UpperHex for UpperHexFromDisplay<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl<T: Display> UpperHexFromDisplay<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromLowerExp<T: LowerExp> (pub T);
impl<T: LowerExp> From<T> for UpperHexFromLowerExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerExp> UpperHex for UpperHexFromLowerExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerExp::fmt(&self.0, f)
}
}
impl<T: LowerExp> UpperHexFromLowerExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromLowerHex<T: LowerHex> (pub T);
impl<T: LowerHex> From<T> for UpperHexFromLowerHex<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: LowerHex> UpperHex for UpperHexFromLowerHex<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
LowerHex::fmt(&self.0, f)
}
}
impl<T: LowerHex> UpperHexFromLowerHex<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromOctal<T: Octal> (pub T);
impl<T: Octal> From<T> for UpperHexFromOctal<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Octal> UpperHex for UpperHexFromOctal<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Octal::fmt(&self.0, f)
}
}
impl<T: Octal> UpperHexFromOctal<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromPointer<T: Pointer> (pub T);
impl<T: Pointer> From<T> for UpperHexFromPointer<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: Pointer> UpperHex for UpperHexFromPointer<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
Pointer::fmt(&self.0, f)
}
}
impl<T: Pointer> UpperHexFromPointer<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}
#[repr(transparent)]
pub struct UpperHexFromUpperExp<T: UpperExp> (pub T);
impl<T: UpperExp> From<T> for UpperHexFromUpperExp<T> {
#[inline(always)]
fn from(op: T) -> Self {
Self(op)
}
}
impl<T: UpperExp> UpperHex for UpperHexFromUpperExp<T> {
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
UpperExp::fmt(&self.0, f)
}
}
impl<T: UpperExp> UpperHexFromUpperExp<T> {
#[inline(always)]
pub fn into_inner(self) -> T {
self.0
}
}