dobkeratops

use std::io::println;
use rf_common::*;
use syntax::ast;
use rustc::middle::{ty,typeck};
use syntax::codemap::{BytePos, Pos};
use rsfind::ShowDefMode;

...

dobkeratops

template<typename T, typename OFFSET=int, 
    int ALIGN_SHIFT=2>
class   OffsetPtr 
{
    OFFSET  ofs;

public:
    T* operator->() {
        return  (T*) (((((size_t)this)>>ALIGN_SHIFT)+ofs)<<ALIGN_SHIFT);
    };

dobkeratops

struct Blob<HEADER> {
    data:~[u8],
}

impl<T> std::ops::Deref<T> for Blob<T> {
    fn deref<'s>(&'s self)->&'s T {
        //assert!(self.num_bytes() > std::intrinsics::size_of::<T>());
        unsafe {    &*(&self.data[0] as *u8 as *T)

dobkeratops

// Developped from a use case: use of a precompiled object graph in a single allocation, 
// internally using compact relative pointers, interfacing with a C library (openGL)


/// return a reference to a different type at a byte offset from the given base object reference
unsafe fn byte_ofs_ref<'a,X,Y,I:Int=int>(base:&'a X, ofs:I)->&'a Y {
    &*( (base as *_ as *u8).offset( ofs.to_int().unwrap() ) as *Y)
}
/// return a raw ptr to a different type at a byte offset from the given base object reference
unsafe fn byte_ofs_ptr<'a,X,Y,I:Int=int>(base:&'a X, ofs:I)->*Y {

dobkeratops

use std::{io,mem,raw,cast};


struct BlobContainingSlices<'a>  {
	data:~[u8],
	subset1: &'a [u32],
	subset2: &'a [u16],
}

fn slice_within_as<TO,FROM>(owner:&[FROM], start:uint, len_in_new_units:uint)->&[TO] {

dobkeratops

#[feature(macro_rules)];
use std::{cast};

// emulating C++ classes using Traits as vtables, could the safety be improved?

pub trait Foo {
	fn foo(&self,i:int);
}

pub struct CppClass<RawDataStruct,TraitInterface> {

dobkeratops

#[feature(macro_rules)];
#[allow(macro_rules)];
use std::{io,mem,raw,cast};
 
// emulating C++ classes using Traits as vtables, could the safety be improved?
 
pub trait Foo {
	fn foo(&self,i:int);
}
 

dobkeratops

struct A{
	x:int,y:int
}

struct B{
	p:int,q:int
}
struct C{
	a:A,b:B
}

dobkeratops

#![feature(default_type_params)]
use std::iter::RandomAccessIterator;

trait ScatterInto<'a, T,INDEX=uint> {
	fn scatter_into<SRC:Iterator<(INDEX,T)>> (&mut self, src:SRC);
	fn scatter_by_indices<IDXS:Iterator<INDEX>, TS:Iterator<T>> (&mut self, indices:IDXS,values:TS) { self.scatter_into(indices.zip(values) ) }
}

trait ScatterIntoGrow<'a, T,INDEX=uint> {
	/// Scatter values into a collection, and grow it if its not large enough

dobkeratops

pub enum TileHolder<T> { // <<<< doesn't work
	EmptyTile(T),
	DataTile(~Array8x8<T>)
}
//...
impl<T:Clone+Eq> TileHolder<T> {
	fn change_to_data_if_not(&mut self,desiredValue:&T) {
		match self {
			&EmptyTile(ref x)=> {
				if x!=desiredValue