gcontrol.cpp

Go to the documentation of this file.
00001 // gcontrol.cpp -- Version 0.2
00002 
00003 #include <string.h>
00004 #include <stdlib.h>
00005 #include <stdarg.h>  // va_start...
00006 #include "gcontrol.h"
00007 ////////////////////////////////////////////////////////////
00008 // Static members
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;  // Socket-serv, ... (up to 100)
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  // Return 0 if no log applied, or -1 if dbgFile stream is nil
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  // Or: va_start( ap, formatStr ); vfprintf( dbgFile, formatStr, ap ); va_end( ap );
00076  va_list ap;
00077  va_start( ap, formatStr );
00078  vsnprintf( logBuf, sizeof(logBuf)-1/*force null ended string*/, 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  // Return 0 if o.k.
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  //printf("DBG: deltaObjs=%d (%d, static-stg:%d)\n",deltaObjs,GetNumObjects(),rStaticStgObjs)
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 

Generated on Sat Aug 18 02:40:51 2007 for xpfweb_v2x lib by  doxygen 1.4.2