00001
00002
00003 #include <string.h>
00004 #include <stdlib.h>
00005 #include <stdarg.h>
00006 #include "gcontrol.h"
00007
00008
00009
00010 int gControl::nErrors[ LOG_LOGMAX ];
00011 gList gControl::lLog[ LOG_LOGMAX ];
00012 int gControl::dbgLevelDefault=LOG_INFO;
00013 char gControl::logBuf[4096];
00014 short gControl::intCtrl=-1;
00015 short gStorageControl::assertedNr=0;
00016 sServiceRegister* gStorageControl::pServReg=nil;
00017 int gStorageControl::rStaticStgObjs=GMIN_STAT_OBJ;
00018 short gStorageControl::maxServices=10;
00019 gStorageControl gStorageControl::myself;
00020
00021 gControl::gControl (eStorage aKind)
00022 : gStorage( aKind, e_StgNoStore ),
00023 lastOpError( 0 ),
00024 dbgLevel( dbgLevelDefault )
00025 {
00026 SetError( 0 );
00027 if ( intCtrl==-1 ) gStorageControl::Self().StaticAlloc( "gControl.lLog", LOG_LOGMAX );
00028 intCtrl = 0;
00029 }
00030
00031 t_uint16 gControl::GetRandom (t_uint16 maxRange)
00032 {
00033 return (t_uint16)(rand())%maxRange;
00034 }
00035
00036 void gControl::Reset ()
00037 {
00038 lastOpError = 0;
00039 }
00040
00041 void gControl::ResetLog ()
00042 {
00043 for (int errKind=LOG_ERROR; errKind<LOG_LOGMAX; errKind++) {
00044 nErrors[ errKind ] = 0;
00045 lLog[ errKind ].Delete();
00046 }
00047 }
00048
00049 int gControl::SetError (int opError)
00050 {
00051 char* str;
00052 memset( sStrError, 0x0, sizeof(sStrError) );
00053 lastOpError = opError;
00054 if ( opError==0 ) return 0;
00055 if ( opError==-1 ) {
00056 strcpy( sStrError, "Internal Error" );
00057 return -1;
00058 }
00059 str = strerror( opError );
00060 ASSERTION(str!=nil,"strerror");
00061 strcpy( sStrError, str );
00062 return opError;
00063 }
00064
00065 int gControl::Log (FILE* dbgFile, int level, const char* formatStr, ...)
00066 {
00067
00068 static char kindErr[24], kindStr[24];
00069
00070 if ( level<=LOG_NONE ) return 0;
00071 if ( level>=dbgLevel ) return 1;
00072 ASSERTION(formatStr!=nil,"formatStr!=nil");
00073 memset( logBuf, 0x0, sizeof(logBuf) );
00074
00075
00076 va_list ap;
00077 va_start( ap, formatStr );
00078 vsnprintf( logBuf, sizeof(logBuf)-1, formatStr, ap );
00079 va_end( ap );
00080 switch ( level ) {
00081 case LOG_ERROR:
00082 strcpy( kindErr, "Error" );
00083 break;
00084 case LOG_WARNING:
00085 case LOG_NOTICE:
00086 strcpy( kindErr, "Warning" );
00087 break;
00088 default:
00089 level = LOG_LOGMAX-1;
00090 kindErr[0] = 0;
00091 break;
00092 }
00093 kindStr[0] = 0;
00094 if ( kindErr[0]!=0 ) snprintf( kindStr, sizeof(kindStr), "%s: ", kindErr );
00095 nErrors[ level ]++;
00096 if ( dbgFile==nil ) {
00097 lLog[ level ].Add( logBuf );
00098 DBGPRINT_LOG("DBG: LOG(%d) %s%s\n",level,kindStr,logBuf);
00099 return 1;
00100 }
00101 fprintf( dbgFile, "%s%s", kindStr, logBuf );
00102 return 1;
00103 }
00104
00105 int gControl::ClearLogMem (int level)
00106 {
00107
00108 if ( level <= LOG_NONE ) return -1;
00109 if ( level >= LOG_LOGMAX ) return 1;
00110 lLog[ level ].Delete();
00111 return 0;
00112 }
00113
00114 int gControl::ClearLogMemAll ()
00115 {
00116 int level;
00117 for (level=LOG_NONE+1; ; level++)
00118 if ( ClearLogMem( level )!=0 ) return 0;
00119 return -1;
00120 }
00121
00122 int gControl::ClearAllLogs ()
00123 {
00124 ClearLogMemAll();
00125 return 0;
00126 }
00127
00128 gStorage* gControl::NewObject ()
00129 {
00130 ASSERTION_FALSE("gControl::NewObject");
00131 return nil;
00132 }
00133
00134 gStorageControl::gStorageControl ()
00135 : nServices( 0 )
00136 {
00137 pServReg = new sServiceRegister[ maxServices+1 ];
00138 ASSERTION(pServReg!=nil,"pServReg!=nil");
00139 }
00140
00141 gStorageControl::~gStorageControl ()
00142 {
00143 #ifdef DEBUG
00144 if ( assertedNr==0 ) fprintf(stderr,"@END not called.\n");
00145 #endif //DEBUG
00146 Release();
00147 }
00148
00149 int gStorageControl::NumObjs ()
00150 {
00151 int deltaObjs = GetNumObjects()-rStaticStgObjs;
00152
00153 return deltaObjs;
00154 }
00155
00156 char* gStorageControl::StorageKindName (short refKind)
00157 {
00158 short ref;
00159 char* desc;
00160
00161 ASSERTION(refKind>=0 && refKind<e_UnusedStore,"refKind>=0...");
00162 ;
00163 desc = storeKindDesc[refKind].descStr;
00164 ref = storeKindDesc[refKind].refKind;
00165 ASSERTION(ref==refKind,"ref==refKind");
00166 ASSERTION(desc!=nil,"desc!=nil");
00167 return desc;
00168 }
00169
00170 void gStorageControl::StaticAlloc (char* msgStr, int incrNrStaticStgObjs)
00171 {
00172 ASSERTION(msgStr!=nil,"msgStr!=nil");
00173 DBGPRINT_MIN("DBG:StaticAlloc:%s:(cur=%d)+%d\n",msgStr,rStaticStgObjs,incrNrStaticStgObjs);
00174 rStaticStgObjs += incrNrStaticStgObjs;
00175 }
00176
00177 bool gStorageControl::IsServiceUsed (short servIdx)
00178 {
00179 return GetServiceDescriptor( servIdx ).refKind>0;
00180 }
00181
00182 char* gStorageControl::GetServiceName (short servIdx)
00183 {
00184 ASSERTION(servIdx>=0,"servIdx>=0");
00185 ASSERTION(servIdx<=maxServices,"servIdx<=maxServices");
00186 if ( servIdx==0 ) return (char*)"ROOT";
00187 return pServReg[ servIdx ].descriptor.descStr;
00188 }
00189
00190 sStorageDesc& gStorageControl::GetServiceDescriptor (short servIdx)
00191 {
00192 ASSERTION(servIdx>=0,"servIdx>=0");
00193 ASSERTION(servIdx<=maxServices,"servIdx<=maxServices");
00194 return pServReg[ servIdx ].descriptor;
00195 }
00196
00197 sServiceRegister& gStorageControl::GetService (char* descStr)
00198 {
00199 short refKind;
00200 short servIdx = thisFindService( descStr, refKind );
00201 ASSERTION(servIdx>=0,"servIdx>=0");
00202 return pServReg[ servIdx ];
00203 }
00204
00205 sServiceRegister* gStorageControl::GetServicePtr (char* descStr)
00206 {
00207 short refKind;
00208 short servIdx = thisFindService( descStr, refKind );
00209 if ( servIdx<0 ) return nil;
00210 return &pServReg[ servIdx ];
00211 }
00212
00213 short gStorageControl::RegisterService (char* descStr, short refKind, short servIdx)
00214 {
00215 // Returns -1 on error, or a positive index on success
00216 ;
00217 ASSERTION(descStr!=nil && descStr[0]!=0,"descStr!=nil");
00218 ASSERTION(refKind>0,"refKind>0");
00219 ASSERTION(servIdx==-1 || servIdx>0,"servIdx>0...");
00220 if ( servIdx==-1 ) {
00221 // Find available service
00222 for (servIdx=1; servIdx<=maxServices; maxServices++)
00223 if ( IsServiceUsed( servIdx )==false ) break;
00224 if ( servIdx>maxServices )
00225 return -1;
00226 }
00227 if ( IsServiceUsed( servIdx ) ) return -1;
00228 // Fill-up descriptor
00229 nServices++;
00230 ASSERTION(nServices<=maxServices,"nServices<=maxServices");
00231 pServReg[ servIdx ].descriptor.descStr = new char[ strlen(descStr)+1 ];
00232 strcpy( pServReg[ servIdx ].descriptor.descStr, descStr );
00233 pServReg[ servIdx ].descriptor.refKind = refKind;
00234 return servIdx;
00235 }
00236
00237 void gStorageControl::ServiceAlloc (char* descStr, unsigned nNodes)
00238 {
00239 if ( nNodes>0 ) GetService( descStr ).nMediumNodes = nNodes;
00240 GetService( descStr ).AllocateNodes();
00241 }
00242
00243 bool gStorageControl::ServiceAdd (char* descStr, sServiceNode& aNode)
00244 {
00245 sServiceRegister* regPtr = GetServicePtr( descStr );
00246 ASSERTION(regPtr!=nil,"ServiceAdd(1)"); //Must give a valid service name
00247 if ( regPtr->HasNodes()==false ) return false;
00248 ASSERTION(regPtr->data!=nil,"ServiceAdd(2)");
00249 regPtr->data->Add( aNode );
00250 // Replace 'used' attribute on referenced node as 'unused'
00251 aNode.used = -1;
00252 return true;
00253 }
00254
00255 bool gStorageControl::ServiceDelete (char* descStr, gStorage* pStorage)
00256 {
00257 sServiceRegister* regPtr = GetServicePtr( descStr );
00258 ASSERTION(regPtr!=nil,"ServiceDelete(1)"); //Must give a valid service name
00259 if ( regPtr->HasNodes()==false ) return false;
00260 ASSERTION(regPtr->data!=nil,"ServiceDelete(3)");
00261 return regPtr->data->Delete( pStorage );
00262 }
00263
00264 void gStorageControl::Release ()
00265 {
00266 #ifdef DEBUG
00267 int deltaObjs = NumObjs();
00268 if ( deltaObjs>0 ) fprintf(stderr,"Uncleaned (nObjs=%d)\n",deltaObjs);
00269 #endif //DEBUG
00270 ClearAllLogs();
00271 delete[] pServReg;
00272 pServReg = nil;
00273 }
00274
00275 short gStorageControl::thisFindService (char* descStr, short& refKind)
00276 {
00277 // Returns -1 on error, or a positive index on success
00278 ;
00279 short servIdx;
00280 ASSERTION(descStr!=nil && descStr[0]!=0,"descStr!=nil");
00281 refKind = 0;
00282 for (servIdx=0; servIdx<=maxServices; servIdx++) {
00283 char* str = pServReg[ servIdx ].descriptor.descStr;
00284 if ( str==nil ) continue;
00285 //printf("DBG:FIND(%s,%dof%d)\n",str,servIdx,maxServices);
00286 ASSERTION(str!=nil,"str!=nil");
00287 if ( strcmp( descStr, str )==0 ) {
00288 refKind = pServReg[ servIdx ].descriptor.refKind;
00289 return servIdx;
00290 }
00291 }
00292 fprintf(stderr,"@STG: Not found service: %s\n",descStr);
00293 return -1;
00294 }
00295
00296