pr47 0.0.1

A semi-experimental programming language. Still working in progress.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::any::TypeId;
use std::convert::TryFrom;

use crate::vm::{GcInfo, Pr47PtrNonNull, Pr47Ptr};
use crate::error::Pr47Error;
use crate::util::type_traits::is_copy;

pub trait CastFromPr47<T> {
    type CastResult = T;
    fn any_cast(ptr: &Pr47Ptr) -> Result<Self::CastResult, Pr47Error>;
}

impl<T: 'static> CastFromPr47<T> for Pr47Ptr {
    default fn any_cast(ptr: &Pr47Ptr) -> Result<T, Pr47Error> {
        <Pr47Ptr as CastFromPr47NonNull<T>>::any_cast_non_null(&Pr47PtrNonNull::try_from(ptr)?)
    }
}

impl<T: 'static> CastFromPr47<Option<T>> for Pr47Ptr {
    fn any_cast(ptr: &Pr47Ptr) -> Result<Option<T>, Pr47Error> {
        Pr47PtrNonNull::try_from(ptr).map_or(
            Ok(None),
            |ptr_non_null| {
                Ok(Some(<Pr47Ptr as CastFromPr47NonNull<T>>::any_cast_non_null(&ptr_non_null)?))
            })
    }
}

pub trait CastFromPr47NonNull<T> {
    type CastResult = T;
    fn any_cast_non_null(ptr: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error>;
}

impl<T: 'static> CastFromPr47NonNull<T> for Pr47Ptr {
    default fn any_cast_non_null(ptr: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error> {
        if is_copy::<T>() {
            <Self as CastHelperCopy<Self::CastResult>>::cast_copy(ptr)
        } else {
            unsafe {
                if ptr.gc_info_ptr.as_ref().load(std::sync::atomic::Ordering::SeqCst)
                    != GcInfo::MovedToHost.into() {
                    Err(Pr47Error::NotMove)
                } else {
                    Ok(
                        *Box::from_raw(
                            ptr.data_ptr.as_ref()
                                .cast(TypeId::of::<T>(), std::any::type_name::<T>())
                                .unwrap()
                                .cast::<T>()
                                .as_ptr()))
                }
            }
        }
    }
}

trait CastHelperCopy<T> {
    type CastResult = T;
    fn cast_copy(ptr: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error>;
}

impl<T: 'static> CastHelperCopy<T> for Pr47Ptr {
    default fn cast_copy(ptr: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error> {
        unreachable!()
    }
}

impl<T: 'static + Copy> CastHelperCopy<T> for Pr47Ptr {
    fn cast_copy(ptr: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error> {
        unsafe {
            Ok(*ptr.data_ptr
                .as_ref()
                .cast(TypeId::of::<T>(), std::any::type_name::<T>())?
                .cast::<T>()
                .as_ref())
        }
    }
}

impl<T: 'static> CastFromPr47NonNull<&'_ T> for Pr47Ptr {
    fn any_cast_non_null(reference: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error> {
        unsafe {
            if reference.gc_info_ptr.as_ref().load(std::sync::atomic::Ordering::SeqCst)
                != GcInfo::SharedWithHost.into() {
                Err(Pr47Error::NotBorrow)
            } else {
                Ok(reference.data_ptr
                    .as_ref()
                    .cast(TypeId::of::<T>(),
                          std::any::type_name::<T>())?
                    .cast::<T>()
                    .as_ptr()
                    .as_ref()
                    .unwrap())
            }
        }
    }
}

impl<T: 'static> CastFromPr47NonNull<&'_ mut T> for Pr47Ptr {
    fn any_cast_non_null(reference: &Pr47PtrNonNull) -> Result<Self::CastResult, Pr47Error> {
        unsafe {
            if reference.gc_info_ptr.as_ref().load(std::sync::atomic::Ordering::SeqCst)
                != GcInfo::MutSharedWithHost.into() {
                Err(Pr47Error::NotBorrow)
            } else {
                Ok(reference.data_ptr
                    .as_ref()
                    .cast(TypeId::of::<T>(),
                          std::any::type_name::<T>())?
                    .cast::<T>()
                    .as_ptr()
                    .as_mut()
                    .unwrap())
            }
        }
    }
}