DynArr.hpp

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder

#ifndef DYNARR_HPP
#define DYNARR_HPP

// %% DYNOBJ options generate(implement) 

#include "pi/int64.h"

template<class T>
class DynArrI;

typedef DynArrI<char>    DynArrChar;
typedef DynArrI<wchar_t> DynArrWCharT;
typedef DynArrI<short>   DynArrShort;
typedef DynArrI<int>     DynArrInt;
typedef DynArrI<int64>   DynArrInt64;
typedef DynArrI<void*>   DynArrPtr;
typedef DynArrI<VObj*>   DynArrPtrVObj;
typedef DynArrI<DynI*>   DynArrPtrDynI;

template<>
class doTypeInfo<DynArrI<wchar_t> >{
public:
    static int Id( ){ return DYNARRWCHART_TYPE_ID; }
    static const char* Name( ){ return "DynArrWCharT"; }
};

// This is a more general type info that maps all DynArrI of the
// same item size to the same type.
// This is for all pointers:
template<class T>
class doTypeInfo<DynArrI<T*> >{
public:
    static int Id( ){ return DYNARRPTR_TYPE_ID; }
    static const char* Name( ){ return "DynArrPtr"; }
};

// Specialization for VObj
template<>
class doTypeInfo<DynArrI<VObj*> >{
public:
    static int Id( ){ return DYNARRPTRVOBJ_TYPE_ID; }
    static const char* Name( ){ return "DynArrPtrVObj"; }
};

// Specialization for DynI
template<>
class doTypeInfo<DynArrI<DynI*> >{
public:
    static int Id( ){ return DYNARRPTRDYNI_TYPE_ID; }
    static const char* Name( ){ return "DynArrPtrDynI"; }
};

// This is for primitive types
template<class T>
class doTypeInfo<DynArrI<T> >{
public:
    static int Id( ){
        switch(sizeof(T)){
            case 1: return DYNARRCHAR_TYPE_ID;
            case 2: return DYNARRSHORT_TYPE_ID;
            case 4: return DYNARRINT_TYPE_ID;
            case 8: return DYNARRINT64_TYPE_ID;
            default: return INVALID_TYPE_ID;
        }
    }
    static const char* Name( ){
        switch(sizeof(T)){
            case 1: return "DynArrChar";
            case 2: return "DynArrShort";
            case 4: return "DynArrInt";
            case 8: return "DynArrInt64";
            default: return NULL;
        }
    }
};


#include "utils/ArrBase.hpp"

#define DA_AT_END ((int)0x80000000)


// Dynamic array base interface
template<class T>
class DynArrI : public DynObj {
public:
    virtual DynObjType* docall doGetType( const DynI **pself ) const;

    // Through the ArrBase class, all ops that don't increase the array size can be done
    virtual const ArrBase<T,int>& docall GetArrBase( ) const = 0;
    virtual T&   docall ElemRef( int ix ) = 0;

    virtual DynArrI& docall Push( T t ) = 0;
    virtual T    docall Pop( ) = 0;
    virtual T&   docall Top( ) = 0;

    virtual DynArrI& docall Empty( ) = 0;
    virtual bool     docall MakeSpaceAt( int at_ix, int n_space=1 ) = 0;
    virtual DynArrI& docall OverWrite( const T* pt, int cnt, int at_ix ) = 0;

    virtual T& docall GetNullElem() const {
        static T t;
        return t;
    }


    // Convenience inline functions
    // Rules: 1 - Avoid error reporting here (it will use different means than impl)
    //        2 - Avoid any memory alloc
    //        3 - Low/reasonable complexity
    //        4 - Where chances is that derived class would have different way
    //            of doing it, then don't.
    T*  Base( ) const { return GetArrBase().Base(); }
    int Size( ) const { return GetArrBase().Size(); }
    T& operator [] (int ix){ return ElemRef(ix); }
    T ElemSafe( int ix ) const {
        ArrBase<T,int> &ab = GetArrBase();
        if( ix<0 || ix>=ab.Size() ) return GetNullElem();
        return ab.Base()[ix];
    }

    // Insert one element at given position of array
    DynArrI& InsertOrdered( const T& elem, int ix ){
        MakeSpaceAt( ix,1 );
        GetArrBase().Base()[ix] = elem;
        return *this;
    }

    // Insert a number of elements, at any position of the array
    DynArrI& Insert( const T* pt, int cnt, int at_ix=DA_AT_END ){
        if( at_ix==DA_AT_END ) at_ix=this->Size();
        if( !MakeSpaceAt(at_ix,cnt) ) return *this;
        return OverWrite( pt, cnt, at_ix );
    }
};

typedef DynArrI<char>    DynArrChar;
typedef DynArrI<wchar_t> DynArrWCharT;
typedef DynArrI<short>   DynArrShort;
typedef DynArrI<int>     DynArrInt;
typedef DynArrI<int64>   DynArrInt64;
typedef DynArrI<void*>   DynArrPtr;
typedef DynArrI<VObj*>   DynArrPtrVObj;
typedef DynArrI<DynI*>   DynArrPtrDynI;

// Declare classes
// %% DYNOBJ class(dyni) name(DynArrChar)    bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrWCharT)  bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrShort)   bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrInt)     bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrInt64)   bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrPtr)     bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrPtrVObj) bases(DynObj) flags(notypeid,noproto,template)
// %% DYNOBJ class(dyni) name(DynArrPtrDynI) bases(DynObj) flags(notypeid,noproto,template)


// %%DYNOBJ section implement
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DYNARR

// Generate type information that auto-registers on module load
DynObjType g_do_vtype_DynArrChar("DynArrChar","DynObj",DYNARRCHAR_TYPE_ID,0,sizeof(DynArrChar),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrChar::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrChar;
}
DynObjType g_do_vtype_DynArrWCharT("DynArrWCharT","DynObj",DYNARRWCHART_TYPE_ID,0,sizeof(DynArrWCharT),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrWCharT::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrWCharT;
}
DynObjType g_do_vtype_DynArrShort("DynArrShort","DynObj",DYNARRSHORT_TYPE_ID,0,sizeof(DynArrShort),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrShort::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrShort;
}
DynObjType g_do_vtype_DynArrInt("DynArrInt","DynObj",DYNARRINT_TYPE_ID,0,sizeof(DynArrInt),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrInt::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrInt;
}
DynObjType g_do_vtype_DynArrInt64("DynArrInt64","DynObj",DYNARRINT64_TYPE_ID,0,sizeof(DynArrInt64),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrInt64::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrInt64;
}
DynObjType g_do_vtype_DynArrPtr("DynArrPtr","DynObj",DYNARRPTR_TYPE_ID,0,sizeof(DynArrPtr),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrPtr::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrPtr;
}
DynObjType g_do_vtype_DynArrPtrVObj("DynArrPtrVObj","DynObj",DYNARRPTRVOBJ_TYPE_ID,0,sizeof(DynArrPtrVObj),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrPtrVObj::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrPtrVObj;
}
DynObjType g_do_vtype_DynArrPtrDynI("DynArrPtrDynI","DynObj",DYNARRPTRDYNI_TYPE_ID,0,sizeof(DynArrPtrDynI),NULL,NULL,__FILE__);
template<>
DynObjType* DynArrPtrDynI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynArrPtrDynI;
}
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif // DYNLIST_H

---