void *testThreadTwo(void *p)
{
PRINTLOG(LOG_TRACE, ">>%s %s %d %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__);
int i = 20000;
while (i--)
{
PRINTLOG(LOG_INFO, " %s %s %d %s %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__, "there is thread two");
}
PRINTLOG(LOG_TRACE, "<<%s %s %d %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__);
}
int main()
{
int ret = 0;
ret = InitLog(LOG_DEBUG, OUT_FILE);
//ret = InitLog(LOG_DEBUG, OUT_STDOUT);
PRINTLOG(LOG_DEBUG, "%s%d\n", "wuhongtao", 123, 999);
PRINTLOG(LOG_DEBUG, "%s%d\n", "wuhongtao");
PRINTLOG(LOG_DEBUG, "%s%d\n", "wuhongtao", 789);
PRINTLOG(LOG_DEBUG, "%s %d %s\n", __FILE__, __LINE__, __FUNCTION__);
FreeLog();
_CrtDumpMemoryLeaks();
return 0;
}
/***
PRIVATE
Metodo GetUserType
Obtem o tipo de um usuario
Parameters:
-
-
Return:
- o tipo do usuario ou um valor negativo indicando erro
Comments:
-
***/
long
LBSC_Session::GetUserType( LBSC_Base *pUDB, char *szUserName )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::GetUserType") );
if( !pUDB || !szUserName ){
ERETURN( LBSE_BADARG );
}
// procurar o usuario na UDB (a password nao interessa)
int iRet = FindUser( pUDB, szUserName, "$" );
if( iRet != LBS_OK && iRet != LBSE_INVALIDPASSWORD ){
// fudeu
ERETURN( iRet );
}
LBSC_Field *pf = (*pUDB)[ USERBASEUSERTYPE ];
if( !pf ){
ERETURN( LBSE_BADUSERBASE );
}
LBSC_Data *pd = (*pf)[ 0 ];
if( !pd ){
ERETURN( LBSE_BADUSERBASE );
}
long lType = (long) (*pd);
SetError( LBS_OK );
return( lType );
}
/***
PUBLIC
Metodo DisableMultipleRecords
Desabilita a carga de varios registros para a memoria. Aqui no LBS, este metodo
nao faz nada. Ele serve para os stubs cliente/servidor
Parameters:
-
Return:
-
Comments:
-
***/
void
LBSC_Base::DisableMultipleRecords()
{
PRINTLOG( _clLBSLog, ("LBSC_Base::DisableMultipleRecords") );
// este metodo eh dummy. esta' implementado nos stubs c/s
}
/***
PUBLIC
Metodo EnableMultipleRecords
Habilita a carga de varios registros para a memoria. Aqui no LBS, este metodo
nao faz nada. Ele serve para os stubs cliente/servidor
Parameters:
- iNumRegs -> numero de registros que devem ser carregados para a memoria
quando uma operacao de leitura de registros for realizada
Return:
-
Comments:
-
***/
void
LBSC_Base::EnableMultipleRecords( int /*iNumRegs*/ )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::EnableMultipleRecords") );
// este metodo eh dummy. esta' implementado nos stubs c/s
}
/***
PUBLIC
Metodo GetAllRepetitions
Obtem todas as repeticoes, de varios tipos e tamanhos,
de um ou mais registros, de uma so' vez.
Parameters:
- pTicket -> ticket de seguranca
- iNumRegs -> numero de registros que devem ser lidos
para o LBS obter as repeticoes. O default
eh 1 (apenas o registro corrente).
Return:
- ponteiro para uma tira de bytes contendo informacoes
como descritas no documento de HLD-performance-C/S ou
NULL em caso de erro.
Comments:
- a aplicacao DEVE deletar o buffer retornado por este metodo.
***/
C_Buffer *
LBSC_Base::GetAllRepetitions( const LBSC_Ticket *pTicket, int iNumRegs )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::GetAllRepetitions") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
// algoritmo? Veja no documento de LLD das alteracoes do
// LBS para c/s e LBWMonit
if( bBaseObjOk == FALSE ){
NRETURN( LBSE_OBJNOTOK );
}
if( plbscsOwnerSession->TicketIsOk( pTicket ) != 0 ){
NRETURN( LBSE_TICKETNOTOK );
}
if( lbscrCurrRecord.IsUndefined() ){
NRETURN( LBSE_UNDEFINEDRECORD );
}
C_Buffer *pBuf = NULL;
long lRecordSize = 0;
long lSuggestedPageSize = 0;
if ( !GetRecordBuffer( &pBuf, &lRecordSize, &lSuggestedPageSize, TRUE) ) {
NRETURN( LBSE_NOMEMORY );
}
SetError( LBS_OK );
return( pBuf );
}
/***
PUBLIC
Metodo ClearSynonym
Realiza a delecao de todas as definicoes de sinonimos feita para o
objeto LTC_SYNONYM.
Parameters:
-
Return:
0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::ClearSynonym()
{
PRINTLOG( _clLBSLog, ("LBSC_Base::ClearSynonym") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( !plbscisIndexSystem ){
ERETURN( LBSE_INVALIDINDEXSYSTEM );
}
if( pltcSynonym ){
int iRet = pltcSynonym->LT_ClearSynonym();
if( iRet == 0 ){
LTC_SYNONYM *pAux = plbscisIndexSystem->LT_SetSynonym( NULL );
if( pAux ){
delete pAux;
}
SetError( plbscisIndexSystem->GetError() );
} else {
SetError( pltcSynonym->GetError() );
}
return( iRet );
}
ERETURN( LBSE_NOMEMORY );
}
/**********************************************************
// Function name : LBSC_Session::Delete
// Description :
// Return type : void
// Argument : LBSC_MaintBase *pData
**********************************************************/
void LBSC_Session::Delete( LBSC_MaintBase *pData )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::Delete") );
if( pData ){
delete [] pData;
}
}
/***
STATIC PUBLIC
Metodo GetGroups
Obtem a lista de grupos de uma determinada UDB. Se o parâmetro szUserName
for NULL, o metodo lista todos os grupos de todos os usuários;
caso contrario, lista apenas os grupos do usuário szUserName.
Parameters:
- szUserName -> nome do usuario. Pode ser NULL para
indicar TODOS OS USUARIOS.
- szUDBName -> nome da UDB
- szServerName -> nome do servidor
Return:
- NULL em caso de erro. Uma string contendo os grupos separados
por espacos em branco se correr tudo bem.
Comments:
- O valor retornado DEVE ser deletado pela aplicacao.
***/
char *
LBSC_Session::GetGroups( const char *szUserName, const char *szUDBName, const char * /*szServerName*/ )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::GetGroups") );
char *szReturn = NULL;
int iRet = LBSE_NOMEMORY;
// fazer um login para chamar o outro GetGroups
LBSC_Session *pSession = LBSC_Session::New();
if( pSession ){
// para o SLogin nao interessa o nome do usuario
TNetInfo tni( "$", "$", NULL, NULL, NULL, NULL );
const LBSC_Ticket *pTicket = pSession->SLogin( tni );
if( pTicket ){
szReturn = pSession->GetGroups( pTicket, (char*) szUserName );
iRet = pSession->LastError();
pSession->Logout();
} else {
iRet = pSession->LastError();
}
LBSC_Session::Delete( pSession );
}
SetLastError( (DWORD) (iRet | 0x20000000) );
return( szReturn );
}
/***
PUBLIC
Metodo WhatBasesForUser
Verifica quais as bases disponiveis na rede para um determinado usuario.
Parameters:
- iFilterLevel -> um filtro indicando o que
nao deve ser retornado na lista.
- szUserName: se nao for informado assume-se o usuario que esta
logado.
Return:
- Apontador para uma lista de quadruplas:
[servidor, nome-da-base, nome longo da base, tipo da base, nome da BU]
indicando todas as bases disponiveis na rede para o usuario.
Comments:
- O usuario so pode usar este metodo para ele mesmo, a nao
ser que ele seja super usuario
- Este metodo devera' ser implementado no stub servidor de rede.
- Aqui, o LBS responde apenas por si' mesmo.
***/
LBSC_AllBasesList *
LBSC_Session::WhatBasesForUser( int iFilterLevel, char *szUserName = NULL )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::WhatBasesForUser") );
LBSC_AllBasesList *plbscablAllBasesList;
TAllBases *palbAllBases;
// Verifica se o usuario estah logado
if( bIsLogged == FALSE ){
NRETURN( LBSE_USERNOTLOGGED );
}
if( _bInvalidLicence ){
// a licenca em uso foi invalidada por outra aplicacao.
// devemos sair do ar e retornar para que o LBS revalide
// a licenca.
NRETURN( LBSE_INVALIDLIC );
}
// Checar se o usuario passado eh o mesmo que estah logado ou
// se quem estah logado eh super usuario
if( szUserName ){
if( stricmp( szUserName, plbscuUser->GetUserName() ) != 0 ){
if( plbscuUser->GetUserType() != MASTER_USER ){
NRETURN( LBSE_USERNOTOWNERBASE );
}
}
}
// Instanciar a lista
plbscablAllBasesList = new LBSC_AllBasesList;
if( !plbscablAllBasesList ){
NRETURN( LBSE_NOMEMORY );
}
palbAllBases = new TAllBases; // Instanciar um no'
if( !palbAllBases ){
delete plbscablAllBasesList;
NRETURN( LBSE_NOMEMORY );
}
char *szServerName = WhatServers();
palbAllBases->tmaServer = szServerName;
if( szServerName ){
delete szServerName;
}
palbAllBases->plbscsblServerBasesList = WhatBasesForUserOnServer( iFilterLevel, palbAllBases->tmaServer, szUserName );
if( !(palbAllBases->plbscsblServerBasesList) ){
delete palbAllBases;
palbAllBases = NULL;
} else {
plbscablAllBasesList->Add( palbAllBases, TAIL );
}
if( plbscablAllBasesList->NumElem() == 0 ){
delete plbscablAllBasesList;
plbscablAllBasesList = NULL;
} else {
plbscablAllBasesList->First();
}
SetError( LBS_OK );
return( plbscablAllBasesList );
}
/***
PUBLIC
Metodo GetMask
Obtem a lista de mascaras setada atualmente no sistema de indices.
Parameters:
- iIndex: Informa o indice de onde se quer obter a lista de
mascaras. Podera ser para o indice de Data (DATETREE), Hora
(TIMETREE) ou Valor (VALUETREE).
Return:
- Uma string com a lista de mascaras ativa para aquele indice,
separadas por branco.
Comments:
- Este metodo retorna um apontador para uma string que a
aplicacao DEVE deletar quando nao quiser mais usa-la.
***/
char *
LBSC_Base::GetMask( int iIndex )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::GetMask") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
LTC_TERMLIST *pOldMask;
if( !plbscisIndexSystem ){
NRETURN( LBSE_INVALIDINDEXSYSTEM );
}
if( (iIndex != DATETREE) && (iIndex != TIMETREE) && (iIndex != VALUETREE) ){
NRETURN( LBSE_INVALIDINDEXTYPE );
}
if( pltcMaskList ){
//Início Katyusco
int iMaskType = 1; // Portugues
if ( _pcInter ) {
PRODMAINPARMS *pcInterMianParms = _pcInter->GetProdMainParms();
iMaskType = ( strcmp(pcInterMianParms->currlang, "PORTUGUES") == 0 ? 1 : 0 );
}
pOldMask = plbscisIndexSystem->LT_SetMask( pltcMaskList, iIndex, iMaskType );
SetError( LBS_OK );
return( MakeLTString( pOldMask ) );
}
NRETURN( LBSE_NOMEMORY );
}
/***
PRIVATE
Metodo GetFNameOnProfile
Obtem informacoes do LBS.INI.
Parameters:
- szFullAux
- szAux
Return:
- LBS_OK caso obtenha sucesso.
Comments:
***/
int
LBSC_Session::GetFNameOnProfile( char *szFullAux, char *szAux )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::GetFNameOnProfile") );
strncpy( szFullAux, LBSC_ServerConfig::DirBase(), FULLNAMESIZE-1 );
strncpy( szAux, LBSC_ServerConfig::BasesFileName(), FILENAMESIZE-1 );
// testa se o caminho tem o drive!!!
char szDrive[ _MAX_DRIVE ];
_splitpath ( szFullAux, szDrive, NULL, NULL, NULL );
if ( (szFullAux[0] != '\\' || szFullAux[1] != '\\') && strlen( szDrive ) == 0 ){
// tenta descobrir o drive somente se estiver relativo ao drive onde estamos rodando
getAppDrive( szDrive );
char * szAux = strdup ( szFullAux );
if ( szAux ){
sprintf( szFullAux, "%s%s", szDrive, szAux );
free ( szAux );
}
}
if( ( strcmp( LBSINIDEFMSG, szFullAux ) == 0 ) ||
( strcmp( LBSINIDEFMSG, szAux ) == 0 ) ){
// $$$ deu pau (nao achei a string em LBS.INI)
SetLastError( (DWORD) (LBSE_LBSINIERROR | 0x20000000) );
return( LBSE_LBSINIERROR );
}
SetLastError( LBS_OK | 0x20000000 );
return( LBS_OK );
}
/***
PUBLIC
Metodo PutData
Completa o processo de ordenacao.
Parameters:
- pvKey -> apontador para a chave que esta' ordenada.
Return:
-
Comments:
- Este metodo deve obter, dentro da chave apontada por pvKey,
informacoes necessarias para inserir essa chave na posicao
correta na nova lista de ocorrencias.
***/
void
LBSC_RepSort::PutData( void *pvKey )
{
PRINTLOG( _clLBSLog, ("LBSC_RepSort::PutData") );
if( !pSortField ){
// este objeto nao esta' em condicoes de uso.
return;
}
// extrair de pvKey o ponteiro para o comparator
char *szKey = (char *) pvKey;
pvKey = (void*) (((char*) pvKey) + sizeof( long ));
// obter o ponteiro para a repeticao
LBSC_Data *pd = (LBSC_Data*) (*((long*)pvKey));
if( pd ){
// inserir pd na lista de repeticoes do campo pSortField.
pSortField->IncNumberOfUpdates();
pSortField->lbscdlDataList.Add( pd, TAIL );
pSortField->UpdateFieldFlag( TRUE, iIndAtual );
pd->SetModified( TRUE );
}
++iIndAtual;
delete szKey;
}
/***
PUBLIC
Metodo WhatServersForUser
Verifica quais sao os servidores disponiveis na rede para um determinado
servidor.
Parameters:
- szUserName
Return:
Apontador para uma string contendo os enderecos das maquinas
servidoras separados por um espaco em branco.
Comments:
- Este metodo devera' ser implementado no stub servidor de rede.
- Aqui, o LBS responde apenas por si' mesmo, retornando uma
copia do nome do servidor definido no LBS.INI ou "LOCALHOST".
***/
char *
LBSC_Session::WhatServersForUser( char * szUserName )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::WhatServersForUser") );
// ja' que responderemos por si' mesmo, vamos verificar todas as UDBs
// para saber se o usuario szUserName possui algum acesso
// vamos fazer o seguinte:
// . procurar, no arquivo de controle, todas as UDBs do servidor
// . para cada UDB encontrada, verificar se o usuario possui algum acesso
// . se for encontrado algum acesso, podemos encerrar as buscas e retornar OK
// . se terminarmos de procurar em todas as UDBs e nao encontrarmos nada,
// retornamos NULL
// fim
if( _bInvalidLicence ){
// a licenca em uso foi invalidada por outra aplicacao.
// devemos sair do ar e retornar para que o LBS revalide
// a licenca.
NRETURN( LBSE_INVALIDLIC );
}
C_SessCritSect cCS4( this, CRITSECT4 );
// Procurar usuario (nao importa a password,
// so' importa se ele estah ou nao cadastrado)
if( FindUserInCache( szUserName, NULL, "" ) >= 0 ){
// encontramos o cadastro do cara em alguma UDB
return( WhatServers() );
}
NRETURN( LBSE_USERNOTFOUND );
}
/***
PUBLIC
Metodo GetAllFieldSlots
Retorna os slots de todos os campos
Parameters:
- pTicket -> ticket de seguranca
Return:
- ponteiro para uma estrutura
Comments:
-
***/
TSlotCache *
LBSC_Base::GetAllFieldSlots( const LBSC_Ticket *pTicket )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::GetAllFieldSlots") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( bBaseObjOk == FALSE ){
NRETURN( LBSE_OBJNOTOK );
}
if( plbscsOwnerSession->TicketIsOk( pTicket ) != 0 ){
NRETURN( LBSE_TICKETNOTOK );
}
TSlotCache *ptscRet = new TSlotCache;
if( !ptscRet ){
NRETURN( LBSE_NOMEMORY );
}
ptscRet->iNumberOfFieldSlots = GetNumberOfFields();
ptscRet->pSlots = new TSlotCacheInfo[ ptscRet->iNumberOfFieldSlots ];
if( !ptscRet->pSlots ){
delete ptscRet;
NRETURN( LBSE_NOMEMORY );
}
for( int i = 0; i < ptscRet->iNumberOfFieldSlots; i++ ){
// pra evitar a carga de todos os dados do registro so porque estamos querendo obter a estrutura
BOOL bAux = lbscrCurrRecord.bMustLoadData;
lbscrCurrRecord.bMustLoadData = FALSE;
LBSC_Field *pfField = lbscrCurrRecord[ i ];
// reabilita a carga dos dados dos campos
lbscrCurrRecord.bMustLoadData = bAux;
if( !pfField ){
// deu pau
delete ptscRet;
NRETURN( LBSE_ERROR );
}
ptscRet->pSlots[ i ].uiId = pfField->GetId();
ptscRet->pSlots[ i ].iSize = pfField->lSlotSize;
if( ptscRet->pSlots[ i ].iSize < 0 ){
if( ptscRet->pSlots[ i ].iSize == LBSE_EMPTYSLOT ){
ptscRet->pSlots[ i ].pBuff = NULL;
} else {
delete ptscRet;
return( NULL );
}
} else {
ptscRet->pSlots[ i ].pBuff = new char[ ptscRet->pSlots[ i ].iSize ];
if( !ptscRet->pSlots[ i ].pBuff ){
delete ptscRet;
NRETURN( LBSE_NOMEMORY );
}
memcpy( ptscRet->pSlots[ i ].pBuff, pfField->pvSlot, pfField->lSlotSize );
}
}
SetError( LBS_OK );
return( ptscRet );
}
int main(int argc, char **argv)
{
int ret = 0;
LEVEL level = LOG_TRACE;
OUTWAY outway = OUT_FILE;
//测试未初始化就使用PRINTFLOG的情况
ret = PRINTLOG(LOG_TRACE, "未初始化\n");
printf("未初始化 返回值=%d\n", ret);
//正常的使用方法
InitLog(level, outway);
ret = PRINTLOG(LOG_TRACE, ">>%s %s %d %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__);
printf("输出级别和初始化级别相同 返回值=%d\n", ret);
PRINTLOG(LOG_TRACE, "<<%s %s %d %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__);
FreeLog();
sleep(1);
//输出级别不同于初始化级别的测试
level = LOG_INFO;
InitLog(level, outway);
ret = PRINTLOG(LOG_TRACE, " %s %s %d %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__);
printf("输出级别低于初始化级别 返回值=%d\n", ret);
PRINTLOG(LOG_WARNING, " %s %s %d %s\n",__TIME__, __FILE__, __LINE__, __FUNCTION__);
FreeLog();
sleep(1);
//测试多线程
level = LOG_TRACE;
InitLog(level, outway);
pthread_t t1, t2;
pthread_create(&t1, NULL, testThreadOne, NULL);
pthread_create(&t2, NULL, testThreadTwo, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
FreeLog();
return 0;
}
/***
PUBLIC
Metodo ExchangeOperator
Esta funcao altera mnemonicos para os operadores ou localizadores das
expressoes, permitindo que o usuario utilize os operadores no seu
idioma e da maneira com a qual estiver melhor familiarizado.
Parameters:
-szNewOp: Apontador para uma cadeia de caracteres, terminada
com '\0', contendo os operadores e/ou localizadores seguidos de seu respectivo mnemonico.
Return:
- Retorna um apontador para uma cadeia de caracteres, contendo
os mnemonicos anteriormente setados ou NULL em caso de erro.
Comments:
- Ver metodo LT_ExchangeOperator no manual da GREEN.
***/
char *
LBSC_Base::ExchangeOperator( char *szNewOp )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::ExchangeOperator") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
char *szAux = GLT_Session->LT_ExchangeOperator( szNewOp );
SetError( GLT_Session->LT_GetError() );
return( szAux );
}
/***
PUBLIC
Metodo OLNot
Faz um batimento NOT entre duas listas de ocorrencias
e gera uma terceira lista
Parameters:
- lbscTicket : o ticket de seguranca
- iHandle1 : handle da primeira LO
- iHandle2 : handle da segunda LO
Return:
- o handle da LO gerada ou um erro (valor negativo)
Comments:
- a LO gerada NAO se torna a corrente
(ela nao eh habilitada)
***/
int
LBSC_Base::OLNot( const LBSC_Ticket *lbscTicket, int iHandle1, int iHandle2 )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::OLNot") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( plbscsOwnerSession->TicketIsOk( lbscTicket ) != 0 ){
ERETURN( LBSE_TICKETNOTOK );
}
return( LogicalOp( OL_NOT, iHandle1, iHandle2 ) );
}
/***
PUBLIC
Metodo ClearMasks
Deleta a lista de mascaras.
Parameters:
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::ClearMasks()
{
PRINTLOG( _clLBSLog, ("LBSC_Base::ClearMasks") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( pltcMaskList ){
int iRet = pltcMaskList->LT_DelAllTerm();
ERETURN( LBS_OK );
}
ERETURN( LBSE_NOMEMORY );
}
/***
PUBLIC
Metodo SavePhone
Salva em arquivo o conteudo de um objeto LTC_PHONE, gravando os
fonemas contidos neste objeto.
Parameters:
- szFileName: nome do arquivo (inclusive path).
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::SavePhone( char *szFileName )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::SavePhone") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( pltcPhone ){
int iRet = pltcPhone->LT_SavePhone( szFileName );
SetError( pltcPhone->GetError() );
return( iRet );
}
ERETURN( LBSE_NOMEMORY );
}
/***
PUBLIC
Metodo SaveMasks
Salva a lista de mascaras ativa em um arquivo.
Parameters:
- szFileName: nome do arquivo( inclusive path ).
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::SaveMasks( char *szFileName )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::SaveMasks") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( pltcMaskList ){
int iRet = pltcMaskList->LT_SaveTermList( szFileName );
SetError( pltcMaskList->GetError() );
return( iRet );
}
ERETURN( LBSE_NOMEMORY );
}
/***
PUBLIC
Metodo FindPhone
Realiza uma pesquisa fonetica de um termo. Recebe um termo (ptctTerm)
com parametro e devolve o numero fonetico correspondente a este termo.
Parameters:
- szTerm: termo;
- szPhoneValue:
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::FindPhone( char *szTerm, char *szPhoneValue )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::FindPhone") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( pltcPhone ){
int iRet = pltcPhone->LT_FindPhone( szTerm, szPhoneValue );
SetError( pltcPhone->GetError() );
return( iRet );
}
ERETURN( LBSE_NOMEMORY );
}
/***
PUBLIC
Metodo LoadSynonym
Carrega um objeto LTC_SYNONYM armazenado em arquivo, lendo os termos
e seus sinonimos que serao adicionados no objeto .
Parameters:
-szFileName: nome do arquivo.
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::LoadSynonym( char *szFileName )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::LoadSynonym") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( pltcSynonym ){
int iRet = pltcSynonym->LT_LoadSynonym( szFileName );
SetError( pltcSynonym->GetError() );
return( iRet );
}
ERETURN( LBSE_NOMEMORY );
}
/***
static PUBLIC
Metodo WhatBases
Verifica quais as bases disponiveis na rede.
Parameters:
- iFilterLevel -> um filtro indicando o que
nao deve ser retornado na lista.
Return:
Apontador para uma lista de quadruplas:
[servidor, nome-da-base, tipo da base, nome da BU]
indicando todas as bases disponiveis na rede.
Comments:
- Este metodo devera' ser implementado no stub servidor de rede.
- Aqui, o LBS responde apenas por si' mesmo.
***/
LBSC_AllBasesList * // $$$ lista com: servidor + nome-da-base + nome-longo-da-base + tipo + BU
LBSC_Session::WhatBases( int iFilterLevel )
{
PRINTLOG( _clLBSLog, ("LBSC_Session::WhatBases") );
LBSC_AllBasesList *plbscablAllBasesList;
TAllBases *palbAllBases;
if( _bInvalidLicence ){
// a licenca em uso foi invalidada por outra aplicacao.
// devemos sair do ar e retornar para que o LBS revalide
// a licenca.
SetLastError( (DWORD) (LBSE_INVALIDLIC | 0x20000000) );
return( NULL );
}
// Instanciar a lista
plbscablAllBasesList = new LBSC_AllBasesList;
if( !plbscablAllBasesList ){
SetLastError( (DWORD) (LBSE_NOMEMORY | 0x20000000) );
return( NULL );
}
palbAllBases = new TAllBases;
if( !palbAllBases ){
delete plbscablAllBasesList;
SetLastError( (DWORD) (LBSE_NOMEMORY | 0x20000000) );
return( NULL );
}
char *szServer = WhatServers();
palbAllBases->tmaServer = szServer;
if( szServer ){
delete szServer;
}
palbAllBases->plbscsblServerBasesList = WhatBasesOnServer( iFilterLevel, palbAllBases->tmaServer );
if( !(palbAllBases->plbscsblServerBasesList) ){
delete palbAllBases;
palbAllBases = NULL;
} else {
plbscablAllBasesList->Add( palbAllBases, TAIL );
}
if( plbscablAllBasesList->NumElem() == 0 ){
delete plbscablAllBasesList;
plbscablAllBasesList = NULL;
} else {
plbscablAllBasesList->First();
}
SetLastError( LBS_OK | 0x20000000 );
return( plbscablAllBasesList );
}
/***
PUBLIC
Metodo Standardize
Normaliza a string passada no primeiro parametro, devolvendo uma
outra string com o resultado da operacao.
Parameters:
- szContent: Apontador para uma cadeia de caracteres, contendo
a string a ser normalizada;
- szDestination: Apontador para um buffer para armazenar o
resultado da normalizacao;
- iSize:Tamanho da cadeia apontada por szContent;
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
- Este metodo nao realiza nenhuma operacao sobre o sistema de indices.
Ele eh simplesmente um servico oferecido pela API para normalizar
strings.
***/
int
LBSC_Base::Standardize( char *szContent, char *szDestination, int iSize )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::Standardize") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( !plbscisIndexSystem ){
ERETURN( LBSE_INVALIDINDEXSYSTEM );
}
int iRet = plbscisIndexSystem->LT_Standardize( szContent, szDestination, iSize );
SetError( plbscisIndexSystem->GetError() );
return( iRet );
}
/***
PUBLIC
Metodo FindSynonym
Realiza a pesquisa dos sinonimos de um termo. Recebe um termo (ptctTerm)
como parametro e devolve um conjunto de sinonimos para este termo.
Parameters:
- szTerm: termo.
Return:
Retorna um apontador para uma cadeia de caracteres terminada
com '\0', que contem os sinonimos do termo passado como
parametro, ou NULL em caso de erro.
Comments:
-
***/
char *
LBSC_Base::FindSynonym( char *szTerm )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::FindSynonym") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
LTC_TERMLIST *pOldSynonym;
if( pltcSynonym ){
pOldSynonym = pltcSynonym->LT_FindSynonym( szTerm );
return( MakeLTString( pOldSynonym ) );
}
NRETURN( LBSE_NOMEMORY );
}
/***
PUBLIC
Metodo StartSort
Realiza o processo de ordenacao propriamente dito
Parameters:
-
Return:
- FALSE indica que houve problemas.
- TRUE em caso de sucesso.
Comments:
- A ordenacao eh feita pelo metodo StartSort do objeto SortObject.
- A ordenacao eh feita sobre a propria lista de repeticoes do campo.
***/
BOOL
LBSC_RepSort::StartSort()
{
PRINTLOG( _clLBSLog, ("LBSC_RepSort::StartSort") );
if( !pSortField ){
// este objeto nao esta' em condicoes de uso.
return( NULL );
}
iIndAtual = 0;
BOOL bSortRet = SortObject::StartSort();
iIndAtual = 0;
return( bSortRet );
}
/***
PUBLIC
Metodo LoadMasks
Carrega a lista de mascaras a partir de um arquivo.
Parameters:
- szFileName: nome do arquivo( inclusive path ).
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::LoadMasks( char *szFileName )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::LoadMasks") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
if( pltcMaskList ){
pltcMaskList->LT_DelAllTerm();
int iRet = pltcMaskList->LT_LoadTermList( szFileName );
if( iRet != OK ){
pltcMaskList->LT_DelAllTerm();
ERETURN( LBSE_ERROR );
}
ERETURN( LBS_OK );
}
ERETURN( LBSE_NOMEMORY );
}
/***
static PUBLIC
Metodo WhatServers
Verifica quais sao os servidores disponiveis na rede
Parameters:
Return:
Apontador para uma string contendo os enderecos das maquinas
servidoras separados por um espaco em branco.
Comments:
- Este metodo devera' ser implementado no stub servidor de rede.
- Aqui, o LBS responde apenas por si' mesmo, retornando uma
copia do nome do servidor obtido atraves da funcao NetServerGetInfo ou
do LBS.INI ou "LOCALHOST".
***/
char *
LBSC_Session::WhatServers()
{
PRINTLOG( _clLBSLog, ("LBSC_Session::WhatServers") );
char szServerName[ SERVERNAMESIZE ];
const char *szMachine = GetMachineName();
if( szMachine ){
strcpy( szServerName, szMachine );
} else {
// deu pau na funcao NetServerGetInfo.
// vamos pegar o nome no LBS.INI. Se houver erro, o nome retornado
// sera' "LOCALHOST"
strncpy( szServerName, LBSC_ServerConfig::ServerName(), SERVERNAMESIZE-1 );
}
SetLastError( (DWORD) (LBS_OK | 0x20000000) );
return( Strdup( szServerName ) );
}
/***
PUBLIC
Metodo AddSynonym
Adiciona um conjunto de sinonimos (szSynonymArray) para o termo ptctTerm
Parameters:
- szTerm: String de caracteres, terminado com '\0', indicando
qual e o termo que possui o conjunto de sinonimos;
- szSynonymArray: String de caracteres, terminado com '\0',
que contera as diversas palavras que sao sinonimos do termo
passado como parametro. As palavras desta string deverao estar
separadas por um caracter branco;
- iFlag: Flag indicativo para a utilizacao, ou nao, de
bidirecionamento ou associatividade.
Return:
- 0 se operacao OK ou negativo caso contrario.
Comments:
-
***/
int
LBSC_Base::AddSynonym( char *szTerm, char *szSynonymArray, int iFlag )
{
PRINTLOG( _clLBSLog, ("LBSC_Base::AddSynonym") );
CLBAutoRegCrit AutoRegCrit(&rcRegCrit);
LTC_TERMLIST *pltcTermAux = new LTC_TERMLIST;
if( !pltcTermAux ){
ERETURN( LBSE_NOMEMORY );
}
if( !pltcSynonym ){
delete pltcTermAux;
ERETURN( LBSE_NOMEMORY );
}
if( !plbscisIndexSystem ){
delete pltcTermAux;
ERETURN( LBSE_INVALIDINDEXSYSTEM );
}
if( pltcTermAux->LT_BuildTermList( szSynonymArray ) != LBS_OK ){
SetError( pltcTermAux->GetError() );
delete pltcTermAux;
return( LBSE_ERROR );
}
int iRet = pltcSynonym->LT_AddSynonym( szTerm, pltcTermAux, iFlag );
if( iRet == 0 ){
LTC_SYNONYM *pAux = plbscisIndexSystem->LT_SetSynonym( pltcSynonym );
if( pAux ){
delete pAux;
}
SetError( plbscisIndexSystem->GetError() );
} else {
SetError( pltcSynonym->GetError() );
}
delete pltcTermAux;
return( iRet );
}
