Commit 9ee106d3 authored by jan.koester's avatar jan.koester
Browse files

user use templates

parent c2ce7498
Loading
Loading
Loading
Loading
Loading
+4 −4
Changes for src/authdb.h: 4 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -120,8 +120,8 @@ namespace authdb {

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize = sizeof(T)+(sizeof(Y)*count);
        target->data=new Y[target->datasize];
        memset(target->data,0,target->datasize);
        target->data=(char*) new Y[target->datasize];
        memset((void*)target->data,0,target->datasize);
        char *start =target->data;
        for(int i=0; i< count; ++i){
            memcpy(start+(sizeof(Y)*i),&value[i],sizeof(Y));
@@ -133,13 +133,13 @@ namespace authdb {
    template<class T>
    inline const T *getAuthData(int type,int storage,const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
            return (T*)(*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->type==type && curdat->Data->storage==storage
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                    return (T*)curdat->Data->data;
                }
            }
        }
+12 −137
Changes for src/domain.cpp: 12 added lines, 137 removed lines.
Original line number Diff line number Diff line
@@ -31,135 +31,6 @@
#include "domain.h"
#include "types.h"


namespace authdb {
    inline void setDomainData(AuthData *dat,AuthData::Record **varclass,const char *varname,const char *value){
        AuthData::Record *target=*varclass;

        AuthData *curec=dat;

        uuid_t gid;
        uuid_copy(gid,dat->Data->uuid);

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::DomainData &&
                    uuid_compare(curec->Data->uuid,target->uuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

                    target=curec->Data;
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
            target=*varclass;
        }

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
        target->type=DataType::DomainData;
        target->storage=StorageType::TextStorage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize=strlen(value)+1;
        target->data= new char[target->datasize];
        strcpy(target->data,value);


    }

    inline const char *getDomainData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::TextStorage &&
                    curdat->Data->type==DataType::DomainData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }

    inline void setDomainData(AuthData *dat,AuthData::Record **varclass,const char *varname,int value){
        AuthData::Record *target=*varclass;

        AuthData *curec=dat;

        uuid_t gid;
        uuid_copy(gid,dat->Data->uuid);

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::DomainData &&
                    uuid_compare(curec->Data->uuid,target->uuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

                    target=curec->Data;
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
            target=*varclass;
        }

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
        target->type=DataType::DomainData;
        target->storage=StorageType::IntStorage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize=sizeof(int);
        target->data= new char[target->datasize];
        memcpy(target->data,&value,target->datasize);
    }

    inline int getIntDomainData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return *(*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::IntStorage &&
                    curdat->Data->type==DataType::DomainData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    int ret=-1;
                    memcpy(&ret,curdat->Data->data,sizeof(int));
                    return ret;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }
};

authdb::DomainData::DomainData(uuid_t uuid) :AuthData(uuid){
    uuid_copy(did,uuid);
    _name=nullptr;
@@ -172,28 +43,32 @@ authdb::DomainData::~DomainData(){
}

void authdb::DomainData::setDomainName(const char* name){
    setDomainData(this,&_name,"domainname",name);
    setAuthData<DomainData,char>(DataType::DomainData,StorageType::TextStorage,
                                 this,&_name,"domainname",name,strlen(name)+1);
}

const char * authdb::DomainData::getDomainName(){
    return getDomainData(this,&_name,"domainname");
    return getAuthData<char>(DataType::DomainData,StorageType::TextStorage,this,&_name,"domainname");
}


void authdb::DomainData::setStorageType(int type){
    setDomainData(this,&_storageType,"domainstorage",type);
void authdb::DomainData::setStorageType(const int type){
    setAuthData<DomainData,int>(DataType::DomainData,StorageType::IntStorage,
                                this,&_storageType,"domainstorage",&type,1);
}

int authdb::DomainData::getStorageType(){
    return getIntDomainData(this,&_storageType,"domainstorage");
const int authdb::DomainData::getStorageType(){
    return *getAuthData<int>(DataType::DomainData,StorageType::IntStorage,this,&_storageType,"domainstorage");
}

void authdb::DomainData::setStorageOptions(const char *opts){
    setDomainData(this,&_storageOptions,"domainoptions",opts);
    return setAuthData<DomainData,char>(DataType::DomainData,StorageType::TextStorage,
                                        this,&_storageOptions,"domainoptions",opts,strlen(opts)+1);
}

const char * authdb::DomainData::getStorageOptions(){
    return getDomainData(this,&_storageOptions,"domainoptions");
    return getAuthData<char>(DataType::DomainData,StorageType::TextStorage,
                             this,&_storageOptions,"domainoptions");
}

void authdb::Domain::create(authdb::AuthBackend& backend,class DomainData *data){
+2 −2
Changes for src/domain.h: 2 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -44,8 +44,8 @@ namespace authdb {
        void setDomainName(const char *name);
        const char*getDomainName();

        void setStorageType(int type);
        int getStorageType();
        void setStorageType(const int type);
        const int getStorageType();

        void setStorageOptions(const char *opts);
        const char*getStorageOptions();