← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/emscripten/bind.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-09-20 22:44:35 UTC
  • mfrom: (4.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130920224435-apuwj4fsl3fqv1a6
Tags: 1.5.6~20130920~6010666-1
http://bugs.debian.org/723129
* New snapshot release
* Update the list of supported architectures to the same as libv8
  (Closes: #723129)
* emlibtool has been removed from upstream.
* Fix warning syntax-error-in-dep5-copyright
* Refresh of the patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/emscripten/bind.h
70
70
                GenericFunction invoker,
71
71
                GenericFunction function);
72
72
 
73
 
            void _embind_register_tuple(
 
73
            void _embind_register_value_array(
74
74
                TYPEID tupleType,
75
75
                const char* name,
76
76
                GenericFunction constructor,
77
77
                GenericFunction destructor);
78
78
            
79
 
            void _embind_register_tuple_element(
 
79
            void _embind_register_value_array_element(
80
80
                TYPEID tupleType,
81
81
                TYPEID getterReturnType,
82
82
                GenericFunction getter,
85
85
                GenericFunction setter,
86
86
                void* setterContext);
87
87
 
88
 
            void _embind_finalize_tuple(TYPEID tupleType);
 
88
            void _embind_finalize_value_array(TYPEID tupleType);
89
89
 
90
 
            void _embind_register_struct(
 
90
            void _embind_register_value_object(
91
91
                TYPEID structType,
92
92
                const char* fieldName,
93
93
                GenericFunction constructor,
94
94
                GenericFunction destructor);
95
95
            
96
 
            void _embind_register_struct_field(
 
96
            void _embind_register_value_object_field(
97
97
                TYPEID structType,
98
98
                const char* fieldName,
99
99
                TYPEID getterReturnType,
103
103
                GenericFunction setter,
104
104
                void* setterContext);
105
105
 
106
 
            void _embind_finalize_struct(TYPEID structType);
 
106
            void _embind_finalize_value_object(TYPEID structType);
107
107
 
108
108
            void _embind_register_smart_ptr(
109
109
                TYPEID pointerType,
531
531
    ////////////////////////////////////////////////////////////////////////////////
532
532
 
533
533
    template<typename ClassType>
534
 
    class value_tuple : public internal::noncopyable {
 
534
    class value_array : public internal::noncopyable {
535
535
    public:
536
 
        value_tuple(const char* name) {
 
536
        value_array(const char* name) {
537
537
            using namespace internal;
538
 
            _embind_register_tuple(
 
538
            _embind_register_value_array(
539
539
                TypeID<ClassType>::get(),
540
540
                name,
541
541
                reinterpret_cast<GenericFunction>(&raw_constructor<ClassType>),
542
542
                reinterpret_cast<GenericFunction>(&raw_destructor<ClassType>));
543
543
        }
544
544
 
545
 
        ~value_tuple() {
 
545
        ~value_array() {
546
546
            using namespace internal;
547
 
            _embind_finalize_tuple(TypeID<ClassType>::get());
 
547
            _embind_finalize_value_array(TypeID<ClassType>::get());
548
548
        }
549
549
 
550
550
        template<typename InstanceType, typename ElementType>
551
 
        value_tuple& element(ElementType InstanceType::*field) {
 
551
        value_array& element(ElementType InstanceType::*field) {
552
552
            using namespace internal;
553
 
            _embind_register_tuple_element(
 
553
            _embind_register_value_array_element(
554
554
                TypeID<ClassType>::get(),
555
555
                TypeID<ElementType>::get(),
556
556
                reinterpret_cast<GenericFunction>(
566
566
        }
567
567
 
568
568
        template<typename Getter, typename Setter>
569
 
        value_tuple& element(Getter getter, Setter setter) {
 
569
        value_array& element(Getter getter, Setter setter) {
570
570
            using namespace internal;
571
571
            typedef GetterPolicy<Getter> GP;
572
572
            typedef SetterPolicy<Setter> SP;
573
 
            _embind_register_tuple_element(
 
573
            _embind_register_value_array_element(
574
574
                TypeID<ClassType>::get(),
575
575
                TypeID<typename GP::ReturnType>::get(),
576
576
                reinterpret_cast<GenericFunction>(&GP::template get<ClassType>),
582
582
        }
583
583
 
584
584
        template<int Index>
585
 
        value_tuple& element(index<Index>) {
 
585
        value_array& element(index<Index>) {
586
586
            using namespace internal;
587
587
            ClassType* null = 0;
588
588
            typedef typename std::remove_reference<decltype((*null)[Index])>::type ElementType;
589
 
            _embind_register_tuple_element(
 
589
            _embind_register_value_array_element(
590
590
                TypeID<ClassType>::get(),
591
591
                TypeID<ElementType>::get(),
592
592
                reinterpret_cast<GenericFunction>(&internal::get_by_index<ClassType, ElementType>),
603
603
    ////////////////////////////////////////////////////////////////////////////////
604
604
 
605
605
    template<typename ClassType>
606
 
    class value_struct : public internal::noncopyable {
 
606
    class value_object : public internal::noncopyable {
607
607
    public:
608
 
        value_struct(const char* name) {
 
608
        value_object(const char* name) {
609
609
            using namespace internal;
610
 
            _embind_register_struct(
 
610
            _embind_register_value_object(
611
611
                TypeID<ClassType>::get(),
612
612
                name,
613
613
                reinterpret_cast<GenericFunction>(&raw_constructor<ClassType>),
614
614
                reinterpret_cast<GenericFunction>(&raw_destructor<ClassType>));
615
615
        }
616
616
 
617
 
        ~value_struct() {
618
 
            _embind_finalize_struct(internal::TypeID<ClassType>::get());
 
617
        ~value_object() {
 
618
            _embind_finalize_value_object(internal::TypeID<ClassType>::get());
619
619
        }
620
620
 
621
621
        template<typename InstanceType, typename FieldType>
622
 
        value_struct& field(const char* fieldName, FieldType InstanceType::*field) {
 
622
        value_object& field(const char* fieldName, FieldType InstanceType::*field) {
623
623
            using namespace internal;
624
 
            _embind_register_struct_field(
 
624
            _embind_register_value_object_field(
625
625
                TypeID<ClassType>::get(),
626
626
                fieldName,
627
627
                TypeID<FieldType>::get(),
638
638
        }
639
639
    
640
640
        template<typename Getter, typename Setter>
641
 
        value_struct& field(
 
641
        value_object& field(
642
642
            const char* fieldName,
643
643
            Getter getter,
644
644
            Setter setter
646
646
            using namespace internal;
647
647
            typedef GetterPolicy<Getter> GP;
648
648
            typedef SetterPolicy<Setter> SP;
649
 
            _embind_register_struct_field(
 
649
            _embind_register_value_object_field(
650
650
                TypeID<ClassType>::get(),
651
651
                fieldName,
652
652
                TypeID<typename GP::ReturnType>::get(),
659
659
        }
660
660
 
661
661
        template<int Index>
662
 
        value_struct& field(const char* fieldName, index<Index>) {
 
662
        value_object& field(const char* fieldName, index<Index>) {
663
663
            using namespace internal;
664
664
            ClassType* null = 0;
665
665
            typedef typename std::remove_reference<decltype((*null)[Index])>::type ElementType;
666
 
            _embind_register_struct_field(
 
666
            _embind_register_value_object_field(
667
667
                TypeID<ClassType>::get(),
668
668
                fieldName,
669
669
                TypeID<ElementType>::get(),