MODULE TestCast;

TYPE
   X = EXTENSIBLE RECORD END;
   X1 = EXTENSIBLE RECORD (X) END;
   X2 = EXTENSIBLE RECORD(X1) END;
   X3 = EXTENSIBLE RECORD(X2) END;
   
PROCEDURE handle(IN x: X);
END handle;

PROCEDURE handle1(IN x: X1);
END handle1;

PROCEDURE handle2(IN x: X2);
END handle2;

PROCEDURE handle3(IN x: X3);
END handle3;

PROCEDURE test_cast(IN x: X);
BEGIN
   WITH
      x: X3 DO
      handle3(x);
   |   x: X2 DO
      handle2(x);
   |   x: X1 DO
      handle1(x);
   ELSE
      handle(x);
   END
END test_cast;

PROCEDURE main*();
VAR
   x: X;
   x1: X1;
   x2: X2;
   x3: X3;
   i: INTEGER;
BEGIN
   FOR i := 0 TO 100000000 DO
      test_cast(x);
      test_cast(x1);
      test_cast(x2);
      test_cast(x3);
   END
END main;

END TestCast.

struct X
{
    virtual ~X(){}
};

struct X1 : X
{
};

struct X2 : X1
{
};

struct X3 : X2
{
};

void handle(const X &x)
{
}

void handle1(const X1 &x)
{
}

void handle2(const X2 &x)
{
}

void handle3(const X3 &x)
{
}

void check_type(const X &x)
{
    if (const X3 *x3 = dynamic_cast<const X3 *>(&x))
        handle3(*x3);
    else if (const X2 *x2 = dynamic_cast<const X2 *>(&x))
        handle2(*x2);
    else if (const X1 *x1 = dynamic_cast<const X1 *>(&x))
        handle1(*x1);
    else
        handle(x);
}

int main()
{
X x;
X1 x1;
X2 x2;
X3 x3;
    for (int i = 0; i < 100000000; i++)
    {
    check_type(x);
    check_type(x1);
    check_type(x2);
    check_type(x3);
    }
    return 0;
}

#include "oberon_cast.h"

struct X : oberon::inherit<X>
{
};   

struct X1 : oberon::inherit<X1, X>
{
};   

struct X2 : oberon::inherit<X2, X1>
{
};   

struct X3 : oberon::inherit<X3, X2>
{
};   

void check_type(const X &x)
{
    if (const X3 *x3 = oberon::cast<X3>(x))
        handle3(*x3);
    else if (const X2 *x2 = oberon::cast<X2>(x))
        handle2(*x2);
    else if (const X1 *x1 = oberon::cast<X1>(x))
        handle1(*x1);
    else               
        handle(x);
}

namespace oberon {

typedef const int *type_signature;

struct type_hierarchy
{
    type_signature *m_phierarchy;
    int m_cn;
};

struct type
{
    static const int k_cn_inherited = -1;

    type() : m_type(0) {}

    const type_hierarchy *m_type;
};

template <typename T>
void
init_type_info(type_signature *hierarchy)
{
    hierarchy[T::k_cn_inherited] = &T::k_cn_inherited;
    init_type_info<typename T::base>(hierarchy);
}

template <>
inline
void
init_type_info<type>(type_signature *hierarchy)
{
}

template <typename T, typename B = type>
struct inherit : B
{
    typedef B base;
    static const int k_cn_inherited = base::k_cn_inherited + 1;

    struct type_info : type_hierarchy
    {
        type_signature m_hierarchy[k_cn_inherited + 1];

        type_info()
        {
            m_phierarchy = m_hierarchy;
            m_cn = k_cn_inherited;
            init_type_info<T>(m_hierarchy);
        }
    };

    inherit()
    {
    static type_info s_type_info;
        this->m_type = &s_type_info;
    }
};


template <typename T>
const T *
cast(const type &o)
{
const type_hierarchy &dynamic_type = *o.m_type;
    if (dynamic_type.m_cn < T::k_cn_inherited
     || dynamic_type.m_phierarchy[T::k_cn_inherited] != &T::k_cn_inherited)
        return 0;

    return static_cast<const T *>(&o);   
}

} // namespace oberon

MODULE TestCase;

PROCEDURE handle (x: INTEGER); END handle;
PROCEDURE handle1(x: INTEGER); END handle1;
PROCEDURE handle2(x: INTEGER); END handle2;
PROCEDURE handle3(x: INTEGER); END handle3;

PROCEDURE test(x: INTEGER);
BEGIN
   CASE x OF
   |  3: handle3(x);
   |  2: handle2(x);
   |  1: handle1(x);
   ELSE  handle (x);
   END
END test;

PROCEDURE Do*();
VAR
   i: INTEGER;
BEGIN
   FOR i := 0 TO 100000000 DO
      test(0);
      test(1);
      test(2);
      test(3);
   END
END Do;

END TestCase.

void handle (int x) { }
void handle1(int x) { }
void handle2(int x) { }
void handle3(int x) { }

void test(int x)
{
    switch(x)
    {
        case 3:  handle3(x); break;
        case 2:  handle2(x); break;
        case 1:  handle1(x); break;
        default: handle (x); break;
    }
}

void main(void)
{
    int i;
    for (i = 0; i < 100000000; i++)
    {
        test(0);
        test(1);
        test(2);
        test(3);
    }
}

package pgr.tests;

class X {}
class X1 extends X {}
class X2 extends X1 {}
class X3 extends X2 {}

public class TestCast {

    private static void handle(X x) {}
    private static void handle1(X1 x) {}
    private static void handle2(X2 x) {}
    private static void handle3(X3 x) {}

    public static void main(String[] args) {
        long t1 = System.currentTimeMillis();
        mainTest();
        long t2 = System.currentTimeMillis();
        System.out.println(t2 - t1);
    }

    private static void mainTest() {
        X x = new X();
        X1 x1 = new X1();
        X2 x2 = new X2();
        X3 x3 = new X3();

        for (int i = 0; i <= 100000000; i++) {
            testCast(x);
            testCast(x1);
            testCast(x2);
            testCast(x3);
        }
    }

    private static void testCast(X x) {
        if (x instanceof X3) {
            handle3((X3) x);
        } else if (x instanceof X2) {
            handle2((X2) x);
        } else if (x instanceof X1) {
            handle1((X1) x);
        } else {
            handle(x);
        }
    }
}

MyRecord = RECORD
  ...
  field1: MyMessageObject;
  field2: MyMessageObject;
  field3: MyMessageObject;
  ...
END;

void check_type(const oberon::tagged<X> &x)

namespace oberon {

typedef const int *type_signature;

struct type_hierarchy
{
    type_signature *m_phierarchy;
    int m_cn;
};

struct type
{
    static const int k_cn_inherited = -1;
};

template <typename T>
void
init_type_info(type_signature *hierarchy)
{
    hierarchy[T::k_cn_inherited] = &T::k_cn_inherited;
    init_type_info<typename T::base>(hierarchy);
}

template <>
inline
void
init_type_info<type>(type_signature *hierarchy)
{
}

template <typename T, typename B = type>
struct inherit : B
{
    typedef B base;
    static const int k_cn_inherited = base::k_cn_inherited + 1;

    struct type_info : type_hierarchy
    {
        type_signature m_hierarchy[k_cn_inherited + 1];

        type_info()
        {
            m_phierarchy = m_hierarchy;
            m_cn = k_cn_inherited;
            init_type_info<T>(m_hierarchy);
        }
    };
};

template <typename T>
struct tagged
{
    template <typename U>
    tagged(const U &o)
    : m_o(o)
    {
    static U::type_info s_type_info;
        this->m_type = &s_type_info;
    }

    const T &operator * () const {return m_o;}

    const T &m_o;
    const type_hierarchy *m_type;
};


template <typename T, typename U>
const T *
cast(const tagged<U> &o)
{
const type_hierarchy &dynamic_type = *o.m_type;
    if (dynamic_type.m_cn < T::k_cn_inherited
     || dynamic_type.m_phierarchy[T::k_cn_inherited] != &T::k_cn_inherited)
        return 0;

    return static_cast<const T *>(&o.m_o);   
}

} // namespace oberon

struct type
{
    static const int k_cn_inherited = -1;
};