← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libwx-perl/trusty

« back to all changes in this revision

Viewing changes to cpp/helpers.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Roberto C. Sanchez
  • Date: 2011-01-18 17:17:01 UTC
  • mfrom: (1.3.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20110118171701-z5rfg143qndfrau2
Tags: 1:0.98-1
* New upstream release
  - add epoch, to compensate for upstream going from 0.9702 -> 0.98
* Standards-Version: 3.9.1 (no changes required)

Show diffs side-by-side

added added

removed removed

Lines of Context:
cpp/helpers.cpp
4
4
// Author:      Mattia Barbon
5
5
// Modified by:
6
6
// Created:     29/10/2000
7
 
// RCS-ID:      $Id: helpers.cpp 2800 2010-02-11 22:20:09Z mbarbon $
 
7
// RCS-ID:      $Id: helpers.cpp 2927 2010-06-06 08:06:10Z mbarbon $
8
8
// Copyright:   (c) 2000-2010 Mattia Barbon
9
9
// Licence:     This program is free software; you can redistribute it and/or
10
10
//              modify it under the same terms as Perl itself
14
14
 
15
15
#include "cpp/streams.h"
16
16
#include "cpp/streams.cpp"
 
17
#include "cpp/array_helpers.h"
17
18
 
18
19
#if WXPERL_W_VERSION_GE( 2, 5, 1 )
19
20
    #include <wx/arrstr.h>
771
772
    return av;
772
773
}
773
774
 
774
 
template<class A> class array_thingy
775
 
{
776
 
public:
777
 
    typedef A** lvalue;
778
 
    typedef A* rvalue;
779
 
 
780
 
    rvalue create( size_t n ) const { return new A[n]; }
781
 
    void assign( lvalue lv, rvalue rv ) const { *lv = rv; }
782
 
    void free( rvalue rv ) const { delete[] rv; }
783
 
};
784
 
 
785
 
template<class F, class C>
786
 
int wxPli_av_2_thingarray( pTHX_ SV* avref, typename C::lvalue array,
787
 
                           const F& convertf, const C& thingy )
788
 
{
789
 
    AV* av;
790
 
 
791
 
    if( !SvROK( avref ) || 
792
 
        ( SvTYPE( (SV*) ( av = (AV*) SvRV( avref ) ) ) != SVt_PVAV ) )
793
 
    {
794
 
        croak( "the value is not an array reference" );
795
 
        return 0;
796
 
    }
797
 
    
798
 
    int n = av_len( av ) + 1;
799
 
    typename C::rvalue arr = thingy.create( n );
800
 
 
801
 
    for( int i = 0; i < n; ++i )
802
 
    {
803
 
        SV* t = *av_fetch( av, i, 0 );
804
 
        if( !convertf( aTHX_ arr[i], t ) )
805
 
        {
806
 
            thingy.free( arr );
807
 
            croak( "invalid conversion for array element" );
808
 
            return 0;
809
 
        }
810
 
    }
811
 
 
812
 
    thingy.assign( array, arr );
813
 
 
814
 
    return n;
815
 
}
816
 
 
817
 
class convert_sv
818
 
{
819
 
public:
820
 
    bool operator()( pTHX_ SV*& dest, SV* src ) const
821
 
    {
822
 
        dest = src;
823
 
        return true;
824
 
    }
825
 
};
826
 
 
827
775
int wxPli_av_2_svarray( pTHX_ SV* avref, SV*** array )
828
776
{
829
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_sv(),
830
 
                                  array_thingy<SV*>() );
 
777
    return wxPli_av_2_arrayany( aTHX_ avref, array, wxPli_convert_sv(),
 
778
                                wxPli_array_allocator<SV*>() );
831
779
}
832
780
 
833
781
class convert_udatacd
842
790
 
843
791
int wxPli_av_2_userdatacdarray( pTHX_ SV* avref, wxPliUserDataCD*** array )
844
792
{
845
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_udatacd(),
846
 
                                  array_thingy<wxPliUserDataCD*>() );
 
793
    return wxPli_av_2_arrayany( aTHX_ avref, array, convert_udatacd(),
 
794
                                wxPli_array_allocator<wxPliUserDataCD*>() );
847
795
}
848
796
 
849
 
class convert_uchar
850
 
{
851
 
public:
852
 
    bool operator()( pTHX_ unsigned char& dest, SV* src ) const
853
 
    {
854
 
        dest = (unsigned char) SvUV( src );
855
 
        return true;
856
 
    }
857
 
};
858
 
 
859
797
int wxPli_av_2_uchararray( pTHX_ SV* avref, unsigned char** array )
860
798
{
861
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_uchar(),
862
 
                                  array_thingy<unsigned char>() );
 
799
    return wxPli_av_2_arrayany( aTHX_ avref, array, wxPli_convert_uchar(),
 
800
                                wxPli_array_allocator<unsigned char>() );
863
801
}
864
802
 
865
 
class convert_int
866
 
{
867
 
public:
868
 
    bool operator()( pTHX_ int& dest, SV* src ) const
869
 
    {
870
 
        dest = (int) SvIV( src );
871
 
        return true;
872
 
    }
873
 
};
874
 
 
875
803
int wxPli_av_2_intarray( pTHX_ SV* avref, int** array )
876
804
{
877
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_int(),
878
 
                                  array_thingy<int>() );
 
805
    return wxPli_av_2_arrayany( aTHX_ avref, array, wxPli_convert_int(),
 
806
                                wxPli_array_allocator<int>() );
879
807
}
880
808
 
881
809
#include <wx/menu.h>
910
838
    return SvIV( var );
911
839
}
912
840
 
913
 
class convert_wxstring
914
 
{
915
 
public:
916
 
    bool operator()( pTHX_ wxString& dest, SV* src ) const
917
 
    {
918
 
        WXSTRING_INPUT( dest, const char*, src );
919
 
        return true;
920
 
    }
921
 
};
922
 
 
923
841
int wxPli_av_2_stringarray( pTHX_ SV* avref, wxString** array )
924
842
{
925
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_wxstring(),
926
 
                                  array_thingy<wxString>() );
 
843
    return wxPli_av_2_arrayany( aTHX_ avref, array, wxPli_convert_wxstring(),
 
844
                                wxPli_array_allocator<wxString>() );
927
845
}
928
846
 
929
 
template<class A, class B, B init>
930
 
class wxarray_thingy
931
 
{
932
 
public:
933
 
    typedef A* lvalue;
934
 
    typedef A& rvalue;
935
 
 
936
 
    wxarray_thingy( lvalue lv ) : m_value( lv ) { }
937
 
    rvalue create( size_t n ) const
938
 
    {
939
 
        m_value->Alloc( n );
940
 
        for( size_t i = 0; i < n; ++i )
941
 
            m_value->Add( init );
942
 
        return *m_value;
943
 
    }
944
 
    void assign( lvalue, rvalue ) const { }
945
 
    void free( rvalue ) const {}
946
 
private:
947
 
    A* m_value;
948
 
};
949
 
 
950
 
extern const wxChar wxPliEmptyString[];
951
 
 
952
847
int wxPli_av_2_arraystring( pTHX_ SV* avref, wxArrayString* array )
953
848
{
954
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_wxstring(),
955
 
                                  wxarray_thingy<wxArrayString, const wxChar*, wxPliEmptyString>( array ) );
 
849
    return wxPli_av_2_arrayany( aTHX_ avref, array, wxPli_convert_wxstring(),
 
850
                                wxPli_wxarray_allocator<wxArrayString, const wxChar*>( array ) );
956
851
}
957
852
 
958
853
int wxPli_av_2_arrayint( pTHX_ SV* avref, wxArrayInt* array )
959
854
{
960
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_int(),
961
 
                                  wxarray_thingy<wxArrayInt, int, 0>( array ) );
 
855
    return wxPli_av_2_arrayany( aTHX_ avref, array, wxPli_convert_int(),
 
856
                                wxPli_wxarray_allocator<wxArrayInt, int>( array ) );
962
857
}
963
858
 
964
859
const wxChar wxPliEmptyString[] = wxT("");
999
894
 
1000
895
int wxPli_av_2_charparray( pTHX_ SV* avref, char*** array )
1001
896
{
1002
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_charp(),
1003
 
                                  array_thingy<char*>() );
 
897
    return wxPli_av_2_arrayany( aTHX_ avref, array, convert_charp(),
 
898
                                wxPli_array_allocator<char*>() );
1004
899
}
1005
900
 
1006
901
class convert_wxcharp
1017
912
 
1018
913
int wxPli_av_2_wxcharparray( pTHX_ SV* avref, wxChar*** array )
1019
914
{
1020
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_wxcharp(),
1021
 
                                  array_thingy<wxChar*>() );
 
915
    return wxPli_av_2_arrayany( aTHX_ avref, array, convert_wxcharp(),
 
916
                                wxPli_array_allocator<wxChar*>() );
1022
917
}
1023
918
 
1024
919
#if wxUSE_UNICODE
1198
1093
 
1199
1094
wxPoint wxPli_sv_2_wxpoint_test( pTHX_ SV* scalar, bool* ispoint )
1200
1095
{
1201
 
    return wxPli_sv_2_wxpoint_test<wxPoint, int, convert_int>
1202
 
               ( aTHX_ scalar, convert_int(), "Wx::Point", ispoint );
 
1096
    return wxPli_sv_2_wxpoint_test<wxPoint, int, wxPli_convert_int>
 
1097
               ( aTHX_ scalar, wxPli_convert_int(), "Wx::Point", ispoint );
1203
1098
}
1204
1099
 
1205
1100
wxPoint wxPli_sv_2_wxpoint( pTHX_ SV* scalar )
1206
1101
{
1207
 
    return wxPli_sv_2_wxpoint_test<wxPoint, int, convert_int>
1208
 
               ( aTHX_ scalar, convert_int(), "Wx::Point", 0 );
 
1102
    return wxPli_sv_2_wxpoint_test<wxPoint, int, wxPli_convert_int>
 
1103
               ( aTHX_ scalar, wxPli_convert_int(), "Wx::Point", 0 );
1209
1104
}
1210
1105
 
1211
1106
template<class T>
1305
1200
    bool operator()( pTHX_ wxPoint& dest, SV* src ) const
1306
1201
    {
1307
1202
        bool ispoint;
1308
 
        dest = wxPli_sv_2_wxpoint_test<wxPoint, int, convert_int>
1309
 
                   ( aTHX_ src, convert_int(), "Wx::Point", &ispoint );
 
1203
        dest = wxPli_sv_2_wxpoint_test<wxPoint, int, wxPli_convert_int>
 
1204
                   ( aTHX_ src, wxPli_convert_int(), "Wx::Point", &ispoint );
1310
1205
        return ispoint;
1311
1206
    }
1312
1207
};
1313
1208
 
1314
1209
int wxPli_av_2_pointarray( pTHX_ SV* avref, wxPoint** array )
1315
1210
{
1316
 
    return wxPli_av_2_thingarray( aTHX_ avref, array, convert_wxpoint(),
1317
 
                                  array_thingy<wxPoint>() );
 
1211
    return wxPli_av_2_arrayany( aTHX_ avref, array, convert_wxpoint(),
 
1212
                                wxPli_array_allocator<wxPoint>() );
1318
1213
}
1319
1214
 
1320
1215
class convert_double
1343
1238
 
1344
1239
int wxPli_av_2_point2ddoublearray( pTHX_ SV* avref, wxPoint2DDouble** array )
1345
1240
{
1346
 
    return wxPli_av_2_thingarray( aTHX_ avref, array,
1347
 
                                  convert_wxpoint2ddouble(),
1348
 
                                  array_thingy<wxPoint2DDouble>() );
 
1241
    return wxPli_av_2_arrayany( aTHX_ avref, array,
 
1242
                                convert_wxpoint2ddouble(),
 
1243
                                wxPli_array_allocator<wxPoint2DDouble>() );
1349
1244
}
1350
1245
 
1351
1246
#if WXPERL_W_VERSION_GE( 2, 9, 0 )