//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//! see CMultiXApp::CMultiXApp
CISO8583AuthorizerApp::CISO8583AuthorizerApp(int Argc,char *Argv[],std::string Class) :
CMultiXApp(Argc,Argv,ISO8583Authorizer_SOFTWARE_VERSION,Class,0),
m_NextSTAN(0),
m_TransactionsCommission(0),
m_OurCreditAccount(-1)
{
CreateLogger(ISO8583Authorizer_SOFTWARE_VERSION);
}
CI8DeskSvr():CWin32Svr(SERVICE_NAME, SERVICE_DISCRIPTION, SERVICE_PATH), m_hThread(NULL), m_hExited(NULL),
m_pLogger(NULL), m_plugMgr(NULL), m_pUpdate(NULL), m_pBackup(NULL),m_hRemoteCtrl(NULL),
m_hOneInstance(NULL)
{
CoInitialize(NULL);
m_hExited = CreateEvent(NULL, TRUE, FALSE, NULL);
CreateLogger(&m_pLogger);
AddWindowFireWall();
}
VSCore::VSCore(uint32_t version) :
m_Refs(0), m_Version(version), m_ConfigFile(nullptr)
{
#if defined(VOODOO_DEBUG_MEMORY)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
#endif
// Set up the internal objects
m_Logger = CreateLogger();
m_Parser = CreateParser();
m_Server = CreateServer();
AddThisToDebugCache();
};
//! 读取配置文件并覆写
bool CLogerManager::Config(std::string cfgPath)
{
if (!m_configFile.empty())
{
std::cout << "log4z configure error: too many too call Config. the old config file="<< m_configFile << ", the new config file=" << cfgPath << std::endl;
return false;
}
m_configFile = cfgPath;
std::map<std::string, LoggerInfo> loggerMap;
ParseConfig(cfgPath, loggerMap);
for (std::map<std::string, LoggerInfo>::iterator iter = loggerMap.begin(); iter != loggerMap.end(); ++iter)
{
CreateLogger(iter->second._name,
iter->second._path,
iter->second._level,
iter->second._display,
iter->second._monthdir,
iter->second._limitsize);
}
return true;
}
void Debugger::Init()
{
#if defined(_showdebugger_)
// Try to create file mapping object (assume that this is the server)
m_hMap = ::CreateFileMapping((HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,
(e_MaxLengthOfDebugMsg+1) * sizeof(char),
"ApplicationSpecificSharedMem");
// Check if file mapping object already exists. If it does, then this is a
// client and in this case open existing file mapping object. Client also
// needs to create a mutex object to synchronize access to the server
if (GetLastError() == ERROR_ALREADY_EXISTS) {
m_hMap = ::OpenFileMapping(FILE_MAP_WRITE,FALSE,"ApplicationSpecificSharedMem");
}
// Obtain a pointer from the handle to file mapping object
m_pMsg = (char*)::MapViewOfFile(m_hMap,FILE_MAP_WRITE,0,0,(e_MaxLengthOfDebugMsg+1) * sizeof(char));
CreateLogger();
#endif //defined(_showdebugger_)
}
int main ( int argc, char * argv[] )
{
CppUnit::Test * suite
= CppUnit::TestFactoryRegistry::getRegistry().makeTest();
CppUnit::TextUi::TestRunner runner;
runner.addTest( suite );
tape::Error error;
CreateLogger("/tmp/bdt-test");
bdt::Factory::ResetSchedule(new ScheduleNone());
bdt::Factory::CreateConfigure();
bdt::Factory::GetConfigure()->Refresh("./bdt.config");
runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
std::cerr ) );
bool ret = runner.run();
Factory::ReleaseCacheManager();
Factory::ReleaseTapeManager();
Factory::ReleaseTapeLibraryManager();
Factory::ReleaseMetaManager();
return ret ? 0 : 1;
}
/**
* @brief Entry point of the user-defined function for pg_bulkload.
* @return Returns number of loaded tuples. If the case of errors, -1 will be
* returned.
*/
Datum
pg_bulkload(PG_FUNCTION_ARGS)
{
Reader *rd = NULL;
Writer *wt = NULL;
Datum options;
MemoryContext ctx;
MemoryContext ccxt;
PGRUsage ru0;
PGRUsage ru1;
int64 count;
int64 parse_errors;
int64 skip;
WriterResult ret;
char *start;
char *end;
float8 system;
float8 user;
float8 duration;
TupleDesc tupdesc;
Datum values[PG_BULKLOAD_COLS];
bool nulls[PG_BULKLOAD_COLS];
HeapTuple result;
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
BULKLOAD_PROFILE_PUSH();
pg_rusage_init(&ru0);
/* must be the super user */
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be superuser to use pg_bulkload")));
options = PG_GETARG_DATUM(0);
ccxt = CurrentMemoryContext;
/*
* STEP 1: Initialization
*/
/* parse options and create reader and writer */
ParseOptions(options, &rd, &wt, ru0.tv.tv_sec);
/* initialize reader */
ReaderInit(rd);
/*
* We need to split PG_TRY block because gcc optimizes if-branches with
* longjmp codes too much. Local variables initialized in either branch
* cannot be handled another branch.
*/
PG_TRY();
{
/* truncate heap */
if (wt->truncate)
TruncateTable(wt->relid);
/* initialize writer */
WriterInit(wt);
/* initialize checker */
CheckerInit(&rd->checker, wt->rel, wt->tchecker);
/* initialize parser */
ParserInit(rd->parser, &rd->checker, rd->infile, wt->desc,
wt->multi_process, PG_GET_COLLATION());
}
PG_CATCH();
{
if (rd)
ReaderClose(rd, true);
if (wt)
WriterClose(wt, true);
PG_RE_THROW();
}
PG_END_TRY();
/* No throwable codes here! */
PG_TRY();
{
/* create logger */
CreateLogger(rd->logfile, wt->verbose, rd->infile[0] == ':');
start = timeval_to_cstring(ru0.tv);
LoggerLog(INFO, "\npg_bulkload %s on %s\n\n",
PG_BULKLOAD_VERSION, start);
ReaderDumpParams(rd);
WriterDumpParams(wt);
LoggerLog(INFO, "\n");
BULKLOAD_PROFILE(&prof_init);
/*
* STEP 2: Build heap
*/
/* Switch into its memory context */
Assert(wt->context);
ctx = MemoryContextSwitchTo(wt->context);
/* Loop for each input file record. */
while (wt->count < rd->limit)
{
HeapTuple tuple;
CHECK_FOR_INTERRUPTS();
/* read tuple */
BULKLOAD_PROFILE_PUSH();
tuple = ReaderNext(rd);
BULKLOAD_PROFILE_POP();
BULKLOAD_PROFILE(&prof_reader);
if (tuple == NULL)
break;
/* write tuple */
BULKLOAD_PROFILE_PUSH();
WriterInsert(wt, tuple);
wt->count += 1;
BULKLOAD_PROFILE_POP();
BULKLOAD_PROFILE(&prof_writer);
MemoryContextReset(wt->context);
BULKLOAD_PROFILE(&prof_reset);
}
MemoryContextSwitchTo(ctx);
/*
* STEP 3: Finalize heap and merge indexes
*/
count = wt->count;
parse_errors = rd->parse_errors;
/*
* close writer first and reader second because shmem_exit callback
* is managed by a simple stack.
*/
ret = WriterClose(wt, false);
wt = NULL;
skip = ReaderClose(rd, false);
rd = NULL;
}
PG_CATCH();
{
ErrorData *errdata;
MemoryContext ecxt;
ecxt = MemoryContextSwitchTo(ccxt);
errdata = CopyErrorData();
LoggerLog(INFO, "%s\n", errdata->message);
FreeErrorData(errdata);
/* close writer first, and reader second */
if (wt)
WriterClose(wt, true);
if (rd)
ReaderClose(rd, true);
MemoryContextSwitchTo(ecxt);
PG_RE_THROW();
}
PG_END_TRY();
count -= ret.num_dup_new;
LoggerLog(INFO, "\n"
" " int64_FMT " Rows skipped.\n"
" " int64_FMT " Rows successfully loaded.\n"
" " int64_FMT " Rows not loaded due to parse errors.\n"
" " int64_FMT " Rows not loaded due to duplicate errors.\n"
" " int64_FMT " Rows replaced with new rows.\n\n",
skip, count, parse_errors, ret.num_dup_new, ret.num_dup_old);
pg_rusage_init(&ru1);
system = diffTime(ru1.ru.ru_stime, ru0.ru.ru_stime);
user = diffTime(ru1.ru.ru_utime, ru0.ru.ru_utime);
duration = diffTime(ru1.tv, ru0.tv);
end = timeval_to_cstring(ru1.tv);
memset(nulls, 0, sizeof(nulls));
values[0] = Int64GetDatum(skip);
values[1] = Int64GetDatum(count);
values[2] = Int64GetDatum(parse_errors);
values[3] = Int64GetDatum(ret.num_dup_new);
values[4] = Int64GetDatum(ret.num_dup_old);
values[5] = Float8GetDatumFast(system);
values[6] = Float8GetDatumFast(user);
values[7] = Float8GetDatumFast(duration);
LoggerLog(INFO,
"Run began on %s\n"
"Run ended on %s\n\n"
"CPU %.2fs/%.2fu sec elapsed %.2f sec\n",
start, end, system, user, duration);
LoggerClose();
result = heap_form_tuple(tupdesc, values, nulls);
BULKLOAD_PROFILE(&prof_fini);
BULKLOAD_PROFILE_POP();
BULKLOAD_PROFILE_PRINT();
PG_RETURN_DATUM(HeapTupleGetDatum(result));
}
eResult ArchiverImpl::Init(const char *lpszAppName, const char *lpszConfig, const configsetting_t *lpExtraSettings, unsigned int ulFlags)
{
eResult r = Success;
MAPIINIT_0 sMapiInit = {MAPI_INIT_VERSION, MAPI_MULTITHREAD_NOTIFICATIONS};
if (lpExtraSettings == NULL)
m_lpsConfig = ECConfig::Create(Archiver::GetConfigDefaults());
else {
m_lpDefaults = ConcatSettings(Archiver::GetConfigDefaults(), lpExtraSettings);
m_lpsConfig = ECConfig::Create(m_lpDefaults);
}
if (!m_lpsConfig->LoadSettings(lpszConfig) && (ulFlags & RequireConfig)) {
r = FileNotFound;
goto exit;
}
if (!m_lpsConfig->LoadSettings(lpszConfig)) {
if ((ulFlags & RequireConfig)) {
r = FileNotFound;
goto exit;
}
} else if (m_lpsConfig->HasErrors()) {
if (!(ulFlags & InhibitErrorLogging)) {
ECLogger *lpLogger = new ECLogger_File(EC_LOGLEVEL_FATAL, 0, "-");
LogConfigErrors(m_lpsConfig, lpLogger);
lpLogger->Release();
}
r = InvalidConfig;
goto exit;
}
m_lpLogLogger = CreateLogger(m_lpsConfig, (char*)lpszAppName, "");
if (ulFlags & InhibitErrorLogging) {
// We need to check if we're logging to stderr. If so we'll replace
// the logger with a NULL logger.
ECLogger_File *lpFileLogger = dynamic_cast<ECLogger_File*>(m_lpLogLogger);
if (lpFileLogger && lpFileLogger->IsStdErr()) {
m_lpLogLogger->Release();
m_lpLogLogger = new ECLogger_Null();
}
m_lpLogger = m_lpLogLogger;
m_lpLogger->AddRef();
} else if (ulFlags & AttachStdErr) {
// We need to check if the current logger isn't logging to the console
// as that would give duplicate messages
ECLogger_File *lpFileLogger = dynamic_cast<ECLogger_File*>(m_lpLogLogger);
if (lpFileLogger == NULL || !lpFileLogger->IsStdErr()) {
ECLogger_Tee *lpTeeLogger = new ECLogger_Tee();
lpTeeLogger->AddLogger(m_lpLogLogger);
ECLogger_File *lpConsoleLogger = new ECLogger_File(EC_LOGLEVEL_ERROR, 0, "-", false);
lpTeeLogger->AddLogger(lpConsoleLogger);
lpConsoleLogger->Release();
m_lpLogger = lpTeeLogger;
} else {
m_lpLogger = m_lpLogLogger;
m_lpLogger->AddRef();
}
} else {
m_lpLogger = m_lpLogLogger;
m_lpLogger->AddRef();
}
if (m_lpsConfig->HasWarnings())
LogConfigErrors(m_lpsConfig, m_lpLogger);
if (m_MAPI.Initialize(&sMapiInit) != hrSuccess) {
r = Failure;
goto exit;
}
if (ArchiverSession::Create(m_lpsConfig, m_lpLogger, &m_ptrSession) != hrSuccess) {
r = Failure;
goto exit;
}
exit:
return r;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//! see CMultiXApp::CMultiXApp
CISO8583BackEndApp::CISO8583BackEndApp(int Argc,char *Argv[],std::string Class) :
CMultiXApp(Argc,Argv,ISO8583BackEnd_SOFTWARE_VERSION,Class,0),
m_NextSTAN(0)
{
CreateLogger(ISO8583BackEnd_SOFTWARE_VERSION);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//! see CMultiXApp::CMultiXApp
CISO8583FEApp::CISO8583FEApp(int Argc,char *Argv[],std::string Class) :
CMultiXApp(Argc,Argv,ISO8583FE_SOFTWARE_VERSION,Class,0)
{
CreateLogger(ISO8583FE_SOFTWARE_VERSION);
}
void RenderTest1()
{
RenderParticleTest();
/*
SharedPtr<File> file = CreateFile();
file->open( String("D:\\test.txt"), FILE_MODE_READ, FILE_TEXT);
char buffer[1024];
size_t size = file->read( 5, &buffer[0] );
file->close();
*/
SharedPtr<Foo111> foo = new Foo111;
SharedPtr<Asset> asset;
//asset->addListe
asset = new TextureAsset("Content/tree_foliage.dds");
asset->load();
asset = new TextureAsset("Content/lizard_diff.dds");
asset->load();
//asset = new TextureAsset("Content/lizard_norm.dds");
asset = new TextureAsset("Content/TerrainDiffuseArray.dds");
asset->load();
asset = new TextureAsset("Content/TerrainNormalArray.dds");
//asset = new TextureAsset("Content/Terrain.dds");
//asset = new TextureAsset("Content/Wood.dds");
asset->addListener(foo);
asset->load();
asset->removeListener(foo);
AssetName a1("DisciplesIII");
SharedPtr<Skeleton> skeleton = CreateTestSkeleton();
unsigned numBones = skeleton->getNumBones();
TextureInfo info;
gTextureManager = CreateTextureManager();
SharedPtr<Texture> texture1 = gTextureManager->createTexture(info);
SharedPtr<Texture> texture2 = gTextureManager->createTexture(AssetName("textures/fire.dds"));
MaterialInfo materialInfo;
SharedPtr<Material> material = GetMaterialManager()->createMaterial(materialInfo);
material->setTexture(texture1, MATERIAL_TEXTURE_DEFFUSE);
texture1 = NULL;
texture2 = NULL;
SharedPtr<Geometry> geometry = new Geometry;
geometry->addItem(GeometryItem(3,0));
geometry->addItem(GeometryItem(3,3));
geometry->addItem(GeometryItem(3,6));
geometry->addItem(GeometryItem(0,6,3,4,5));
//geometry->set
size_t s = sizeof(RenderProfile);
Map map;
for (int i = 0; i < 10000000; i++) {
RenderProfile rf;
rf.field = rand();
rf.surface.skinning = 2;
rf.postProcess.msaa = 4;
rf.postProcess.dof = 2;
//map.insert(Map::value_type(rf, NULL));
}
printf("Passed...\n");
SharedPtr<Logger> logger = CreateLogger();
logger->start("MyLog.log");
logger->error("Render", "Hello!");
ShaderDefines shaderDefines;
shaderDefines.addDefine("USE_EMISSION_MAP");
shaderDefines.addDefine("USE_DIFFUSE_MAP");
shaderDefines.addDefine("USE_SPECULAR_MAP");
shaderDefines.addDefine("USE_NORMAL_MAP");
shaderDefines.addDefine("USE_DETAIL_MAP");
shaderDefines.addDefine("USE_FOG");
shaderDefines.addDefine("USE_3DC");
shaderDefines.addDefine("NUM_SAMPLES",8);
String string = shaderDefines.getString();
String defines = shaderDefines.getDefines();
logger->info("Render", string);
logger->info("Render", defines);
logger->stop();
SharedPtr<MemoryBuffer> mb = CreateMemoryBuffer(0xFFFF0000);
if( mb ) {
int* intPtr = (int*)mb->lock();
intPtr[0] = 0xFFFF;
intPtr[0] = 0xDEAD;
mb->unlock();
}
mb=NULL;
ResourceName texture3( "textures/particles/fire.dds");
SharedPtr<RenderScene> rs = CreateRenderScene();
SharedPtr<LightRenderSceneObject> sunLight = new LightRenderSceneObject;
SharedPtr<ParticleSystemRenderSceneObject> particleSystemRenderSceneObject = new ParticleSystemRenderSceneObject;
SharedPtr<TerrainRenderSceneObject> ts = new TerrainRenderSceneObject;
SharedPtr<TextRenderSceneObject> textSceneObject = new TextRenderSceneObject;
SharedPtr<MeshRenderSceneObject> meshSceneObject = new MeshRenderSceneObject;
SharedPtr<LightRenderSceneObject> omniLights1 = new LightRenderSceneObject;
SharedPtr<LightRenderSceneObject> omniLights2 = new LightRenderSceneObject;
SharedPtr<LightRenderSceneObject> omniLights3 = new LightRenderSceneObject;
//rs->
SharedPtr<ParticleSystemManager> particleSystemManager = CreateParticleSystemManager();
SharedPtr<ParticleSystem> particleSystem1 = particleSystemManager->createParticleSystem();
SharedPtr<ParticleSystem> particleSystem2 = particleSystemManager->createParticleSystem();
particleSystem1->addStream( new ParticleStream );
particleSystem1->addStream( new ParticleStream );
particleSystemRenderSceneObject->setParticleSystem(particleSystem1);
particleSystem1 = NULL;
particleSystem2 = NULL;
rs->addLight(sunLight);
LightInfo omniLightInfo;
omniLightInfo.type = LIGHT_OMNI;
omniLights1->setInfo(omniLightInfo);
omniLights2->setInfo(omniLightInfo);
omniLights3->setInfo(omniLightInfo);
omniLights1->setColor(Color::RED, LIGHT_COLOR_DIFFUSE);
rs->addLight(omniLights1);
rs->addLight(omniLights2);
rs->addLight(omniLights3);
DynamicArray<SharedPtr<LightRenderSceneObject>> lights;
rs->getLights(lights);
rs->addMesh(meshSceneObject);
//rs->addSceneObject(ps);
//rs->addSceneObject(textSceneObject);
textSceneObject->setText("Hello,world!");
particleSystemRenderSceneObject->setTransform(Transform());
rs->removeMesh(meshSceneObject);
sunLight->setTransform(Transform());
//light->
rs->removeLight(omniLights1);
rs->removeLight(omniLights2);
rs->removeLight(omniLights3);
rs->removeLight(sunLight);
//rs->removeSceneObject(ps);
/*
HardwareTexture* htexture = NULL;
SharedPtr<TextureSurface> surface[10];
for(unsigned mipLevel =0; mipLevel < 10; mipLevel++) {
htexture->update(mipLevel, surface[mipLevel] );
}
SharedPtr<TextureVolume> volume[10];
for (unsigned mipLevel = 0; mipLevel < 10; mipLevel++) {
//htexture->update(mipLevel, surface[mipLevel]);
htexture->update(mipLevel, volume[mipLevel]);
}
*/
}
