Código: Seleccionar todo

#ifndef _CLS_BYTE_H_
#define _CLS_BYTE_H_

#include <fstream>
#include <stdlib.h>
#include <string.h>
#include "Bytes/modutiles.h"

//    #include <stdbool.h> <-- C ANSI... (C99)CLS_BYTE_CPP

class cls_byte;

#ifndef Struct_clsByte_
#define Struct_clsByte_
struct Struct_clsByte
{
    cls_byte    *pbyt_class;
    size_t      szt_count;
};
#endif  // Struct_clsByte_

class cls_byte
{
private:
    size_t        szt_len;
    Byte          *pbyt_data;
public:
    cls_byte();
    ~cls_byte();

    size_t           Getlen ( );
    Byte       *GetBytesPtr ( );
    struct Struct_Byte *GetBytes ( );

    Byte          *SetBytes ( Byte *pByt_Bytes , size_t szt_lnBytes );  // ok
    Byte          *SetBytes ( cls_byte     *pclsbyteFind );
    Byte          *SetBytes ( Struct_Byte  *pclsbyteFind );             // ok

    bool            SetBytesFromFile( const char *pcchr );
    bool            SetBytesFromFile( const char *pcchr , size_t szt_ini );
    bool            SetBytesFromFile( const char *pcchr , size_t szt_ini , long lng_len );

    cls_byte       *Mid     ( size_t szt_start , size_t szt_len );
    cls_byte       *Mid     ( size_t szt_start );

    Struct_clsByte *Split   ( Byte *pbyt_delimiter , size_t szt_lndelimiter , long lng_limit );
    Struct_clsByte *Split   ( Byte *pbyt_delimiter , size_t szt_lndelimiter );
    Struct_clsByte *Split   ( cls_byte *pclsbytelim , long lng_limit );
    Struct_clsByte *Split   ( cls_byte *pclsbytelim );

    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacemente , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count );
    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente , size_t szt_Start );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente , size_t szt_Start , long lng_Count );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count );
    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );

    size_t            Index ( cls_byte *pclsbyte );
    size_t            Index ( cls_byte *pclsbyte , size_t szt_Start );
    size_t            Index ( cls_byte *pclsbyte , size_t szt_Start , e_CompareMethod enum_Compare );
    size_t            Index ( Byte *pByt_Find , size_t szt_lsf );
    size_t            Index ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start );
    size_t            Index ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , e_CompareMethod enum_Compare );

    bool              Exits ( cls_byte *pclsbyte );
    bool              Exits ( cls_byte *pclsbyte , size_t szt_Start );
    bool              Exits ( cls_byte *pclsbyte , size_t szt_Start , long lng_interval );
    bool              Exits ( cls_byte *pclsbyte , size_t szt_Start , long lng_interval , e_CompareMethod enum_Compare );
    bool              Exits ( Byte *pByt_Find , size_t szt_lsf );
    bool              Exits ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start );
    bool              Exits ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval );
    bool              Exits ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval , e_CompareMethod enum_Compare );
};
//    #include "cls_byte.cpp"
#endif // CLS_BYTE_H

Código: Seleccionar todo

#ifndef _CLS_BYTE_CPP
#define _CLS_BYTE_CPP 1

    #include "cls_byte.h"
    
    cls_byte::cls_byte()
    {
        this->szt_len   = 0;
        this->pbyt_data  = NULL;
    }

    cls_byte::~cls_byte()
        { setnewptrf<Byte*>( this->pbyt_data , NULL ); }

    size_t cls_byte::Getlen()
        { return this->szt_len; }

    Byte *cls_byte::GetBytesPtr()
        { return this->pbyt_data; }

    bool cls_byte::SetBytesFromFile(const char *pcchr)
        { return this->SetBytesFromFile( pcchr , 0 , -1 ); }
    bool cls_byte::SetBytesFromFile(const char *pcchr, size_t szt_ini)
        { return this->SetBytesFromFile( pcchr , szt_ini , -1 ); }
    bool cls_byte::SetBytesFromFile(const char *pcchr, size_t szt_ini, long lng_len)
        {
            FILE            *hfile              = fopen( pcchr , "r+b" );
            Struct_Byte     stbyt_data          = { NULL , 0 };
            size_t          szt_end             = 0;

            if ( hfile != NULL )
            {
                stbyt_data.szt_lenbytes             = flen( hfile );
                if ( lng_len <= -1 )
                    lng_len                             = stbyt_data.szt_lenbytes;
                szt_end = 0;
                if ( fix_numbers_range<size_t>( &szt_ini , &szt_end , &lng_len , NULL ,  0 , stbyt_data.szt_lenbytes-1 ) == true )
                {
                    stbyt_data.pbyt_bytes       = (Byte*)malloc(sizeof(Byte)*lng_len);
                    fseek       ( hfile , (long)szt_ini , SEEK_SET);
                    fread       ( (char*)stbyt_data.pbyt_bytes , 1 , lng_len ,  hfile );
                }
                stbyt_data.szt_lenbytes     = (size_t)lng_len;
                fclose      ( hfile );
                this->SetBytes( &stbyt_data );
            }

        }
    Byte *cls_byte::SetBytes(Struct_Byte *pclsbyteFind)
        { return this->SetBytes( pclsbyteFind->pbyt_bytes , pclsbyteFind->szt_lenbytes ); }
    Byte *cls_byte::SetBytes(cls_byte *pclsbyteFind)
        { return this->SetBytes( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() ); }
    Byte *cls_byte::SetBytes(Byte *pByt_Bytes, size_t szt_lnBytes)
    {
        this->szt_len = szt_lnBytes;
        if ( setnewptrf<Byte*>( this->pbyt_data , ByteClone( pByt_Bytes , this->szt_len ) ) == NULL)
        {
            this->szt_len = 0;
            return pByt_Bytes;
        }
        return NULL;
    }

    Struct_Byte *cls_byte::GetBytes()
    {
        struct Struct_Byte *pstrbyt_ret = (Struct_Byte*)malloc(sizeof(Struct_Byte));
        pstrbyt_ret->pbyt_bytes = ByteClone( this->pbyt_data , this->szt_len );
        pstrbyt_ret->szt_lenbytes =  this->szt_len;
        if ( pstrbyt_ret->pbyt_bytes == NULL )
            pstrbyt_ret->szt_lenbytes = 0;
        return pstrbyt_ret;
    }

    size_t cls_byte::Index(Byte *pByt_Find, size_t szt_lsf)
        { return ByteIndex( this->pbyt_data , this->szt_len  ,pByt_Find , szt_lsf ); }
    size_t cls_byte::Index(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start)
        { return ByteIndex( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start ); }
    size_t cls_byte::Index(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, e_CompareMethod enum_Compare)
        { return ByteIndex( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start , enum_Compare ); }
    size_t cls_byte::Index(cls_byte *pclsbyte)
        { return ByteIndex( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len ); }
    size_t cls_byte::Index(cls_byte *pclsbyte, size_t szt_Start)
        { return ByteIndex( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start ); }
    size_t cls_byte::Index(cls_byte *pclsbyte, size_t szt_Start, e_CompareMethod enum_Compare)
        { return ByteIndex( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start , enum_Compare ); }


    bool cls_byte::Exits(cls_byte *pclsbyte)
        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len ); }
    bool cls_byte::Exits(cls_byte *pclsbyte, size_t szt_Start)
        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start ); }
    bool cls_byte::Exits(cls_byte *pclsbyte, size_t szt_Start, long lng_interval)
        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start , lng_interval ); }
    bool cls_byte::Exits(cls_byte *pclsbyte, size_t szt_Start, long lng_interval, e_CompareMethod enum_Compare)
        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start , lng_interval , enum_Compare ); }
    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf)
        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf ); }
    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start)
        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start ); }
    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, long lng_interval)
        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start , lng_interval ); }
    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, long lng_interval, e_CompareMethod enum_Compare)
        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start , lng_interval , enum_Compare ); }



    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , 0 , -1 , BINARY ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , -1 , BINARY ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , BINARY ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , enum_Compare ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , 0 , -1 , BINARY ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , szt_Start , -1 , BINARY ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , BINARY ); }
    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare )
        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , enum_Compare ); }
    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement )
        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , 0 , -1 , BINARY ); }
    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement , size_t szt_Start )
        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , -1 , BINARY ); }
    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count )
        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , BINARY ); }
    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare )
        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , enum_Compare ); }
    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement)
        { return this->Replace( pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , 0 , -1 , BINARY ); }
    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start)
        { return this->Replace( pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , szt_Start , -1 , BINARY ); }
    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start, long lng_Count)
        { return this->Replace( pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , BINARY ); }
    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start, long lng_Count, e_CompareMethod enum_Compare)
        {
            cls_byte            *cls_Ret    = (cls_byte*)malloc(sizeof(cls_byte));
            Struct_Byte         *pByt_Ret   = NULL;
            Byte                *pByt_ClnF  = ByteClone ( pByt_Find , szt_lnFind );
            Byte                *pByt_ClnR  = ByteClone ( pByt_Replacement , szt_lnReplacement );

            pByt_Ret                = ByteReplace( this->pbyt_data , this->szt_len , pByt_ClnF , szt_lnFind , pByt_ClnR , szt_lnReplacement , szt_Start , lng_Count , enum_Compare );
            cls_Ret->SetBytes       ( pByt_Ret );

            setnewptrf<Byte*>        ( pByt_ClnF , NULL );
            setnewptrf<Byte*>        ( pByt_ClnR , NULL );
            setnewptrf<Byte*>        ( pByt_Ret->pbyt_bytes , NULL );
            setnewptrf<Struct_Byte*> ( pByt_Ret , NULL );

            return cls_Ret;
        }
    cls_byte *cls_byte::Mid(size_t szt_start)
        { return this->Mid   ( szt_start , this->szt_len ); }
    cls_byte *cls_byte::Mid(size_t szt_start, size_t szt_len)
        {
            cls_byte            *cls_Ret    = (cls_byte*)malloc(sizeof(cls_byte));
            Struct_Byte         *pByt_Ret   = NULL;

            pByt_Ret                = ByteMid ( this->pbyt_data , this->szt_len , szt_start , szt_len );
            cls_Ret->SetBytes       ( pByt_Ret );

            setnewptrf<Byte*>        ( pByt_Ret->pbyt_bytes , NULL );
            setnewptrf<Struct_Byte*> ( pByt_Ret , NULL );

            return cls_Ret;
        }

    Struct_clsByte *cls_byte::Split(Byte *pbyt_delimiter, size_t szt_lndelimiter)
        { return this->Split ( pbyt_delimiter , szt_lndelimiter , -1 ); }
    Struct_clsByte *cls_byte::Split(Byte *pbyt_delimiter, size_t szt_lndelimiter, long lng_limit)
        {
            Struct_clsByte      *cls_Ret    = (Struct_clsByte*)malloc(sizeof(Struct_clsByte));
            Struct_Byte_Split   *pByt_Ret   = NULL;
            Byte                *pByt_Clone = ByteClone ( pbyt_delimiter , szt_lndelimiter );

            pByt_Ret                = ByteSplit ( this->pbyt_data , this->szt_len , pByt_Clone , szt_lndelimiter , lng_limit );

            cls_Ret->szt_count      = 0;
            cls_Ret->pbyt_class     = (cls_byte*)malloc(sizeof(cls_byte)*pByt_Ret->szt_ln);

            for ( cls_Ret->szt_count=0 ; cls_Ret->szt_count<pByt_Ret->szt_ln ; ++cls_Ret->szt_count )
            {
                cls_Ret->pbyt_class[ cls_Ret->szt_count ].SetBytes( pByt_Ret->Struct[ cls_Ret->szt_count ] );
                setnewptrf<Byte*>        ( pByt_Ret->Struct[ cls_Ret->szt_count ]->pbyt_bytes , NULL );
                setnewptrf<Struct_Byte*> ( pByt_Ret->Struct[ cls_Ret->szt_count ] , NULL );
            }

            setnewptrf<Byte*>                ( pByt_Clone , NULL );
            setnewptrf<Struct_Byte_Split*>   ( pByt_Ret , NULL );

            return cls_Ret;
        }
    Struct_clsByte *cls_byte::Split(cls_byte *pclsbytelim)
        { return this->Split ( pclsbytelim->GetBytesPtr() , pclsbytelim->Getlen() , -1 ); }
    Struct_clsByte *cls_byte::Split(cls_byte *pclsbytelim, long lng_limit)
        { return this->Split ( pclsbytelim->GetBytesPtr() , pclsbytelim->Getlen() , lng_limit ); }

#endif