예제 #1
0
static int
parseCommandLine( int argc, const char ** argv )
{
    int c;
    const char * optarg;

    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
    {
        switch( c )
        {
            case 'a': add = optarg;
                      break;
            case 'd': deleteme = optarg;
                      break;
            case 'r': replace[0] = optarg;
                      c = tr_getopt( getUsage( ), argc, argv, options, &optarg );
                      if( c != TR_OPT_UNK ) return 1;
                      replace[1] = optarg;
                      break;
            case TR_OPT_UNK: files[fileCount++] = optarg; break;
            default: return 1;
        }
    }

    return 0;
}
예제 #2
0
int main(int argc, char *argv[])
{
	try
	{
		libmaus2::util::ArgInfo const arginfo(argc,argv);
		libmaus2::util::ArgParser const arg(argc,argv);

		if ( arg.argPresent("h") || arg.argPresent("help") )
		{
			std::cerr << getUsage(arg);
			return EXIT_SUCCESS;
		}
		else if ( arg.argPresent("version") )
		{
			std::cerr << "This is " << PACKAGE_NAME << " version " << PACKAGE_VERSION << std::endl;
			return EXIT_SUCCESS;
		}
		else if ( arg.size() < 2 )
		{
			std::cerr << getUsage(arg);
			return EXIT_FAILURE;
		}

		return lassort(arg,arginfo);
	}
	catch(std::exception const & ex)
	{
		std::cerr << ex.what() << std::endl;
		return EXIT_FAILURE;
	}
}
예제 #3
0
void GLBuffer::unmapStream()
{
	// "orphan" current buffer to avoid implicit synchronisation on the GPU:
	// http://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-AsynchronousBufferTransfers.pdf
	glBufferData(getTarget(), (GLsizeiptr) getSize(), nullptr,    getUsage());
	glBufferData(getTarget(), (GLsizeiptr) getSize(), memory_map, getUsage());
}
const std::string& CmdWriteOSGFile::execute( const std::vector< std::string >& arguments )
{
    bool hasinputfile = false;
    if ( arguments.size() < 1 )
    {
        _cmdResult = getUsage();
        return _cmdResult;
    }
    else if ( ( arguments.size() > 2 ) && ( arguments[ 0 ] == "-i" ) )
    {
        hasinputfile = true;
    }
    else
    {
        _cmdResult = getUsage();
        return _cmdResult;
    }

    EnConsole* p_console = static_cast< EnConsole* >( yaf3d::EntityManager::get()->findEntity( ENTITY_NAME_CONSOLE ) );
    assert( p_console && "CmdWriteOSGFile::execute: console entity could not be found!" );
    std::string cwd = yaf3d::Application::get()->getMediaPath() + p_console->getCWD() + "/";
    if ( !hasinputfile )
    {
        osg::Group* grp = yaf3d::Application::get()->getSceneRootNode();
        if ( grp )
        {
            _cmdResult = "writing scene to osg file '" + arguments[ 0 ] + "\n";
            std::string filename = cwd + arguments[ 0 ];

            if ( !osgDB::writeNodeFile( *grp, filename ) )
            {
                _cmdResult += " warning: problem writing file '" + filename + "\n";
            }
        }
    }
    else
    {
        _cmdResult = "reading scene file " + arguments[ 1 ] + " ...\n";
        std::string infilename = cwd + arguments[ 1 ];
        osg::ref_ptr< osg::Node > node = osgDB::readNodeFile( infilename );
        if ( node.get() )
        {
            std::string outfilename = cwd + arguments[ 2 ];
            _cmdResult += "writing scene to file " + outfilename + "\n";

            if ( !osgDB::writeNodeFile( *( node.get() ), outfilename ) )
            {
                _cmdResult += " warning: problem writing file " + outfilename + "\n";
            }
        }
        else
        {
            _cmdResult += "cannot read scene file " + infilename + "\n";
        }
    }

    return _cmdResult;
}
예제 #5
0
void VBO::unmap()
{
	if (!is_mapped)
		return;

	// "orphan" current buffer to avoid implicit synchronisation on the gpu:
	// http://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-AsynchronousBufferTransfers.pdf
	glBufferDataARB(getTarget(), getSize(), NULL,       getUsage());
	glBufferDataARB(getTarget(), getSize(), memory_map, getUsage());
	is_mapped = false;
}
예제 #6
0
int RespondTemplate::execute(int argc, char* argv[])
{
        int status = CommandProcessor::COMMAND_FAILED;
        UtlString usage;

        //printf("no operation command with %d arguments\n", argc);
        if(argc == 1)
        {
                status = CommandProcessor::COMMAND_SUCCESS;
                messageProcessor->stopResponding();
        }
        else if(argc == 2)
        {

                {
                        UtlString fileName;

                        fileName = argv[1];

                        messageProcessor->startResponding(fileName.data(), -1 );
                        status = CommandProcessor::COMMAND_SUCCESS;
                }

        }
        else
        {
                UtlString usage;
                getUsage(argv[0], &usage);
                printf("%s", usage.data());
                status = CommandProcessor::COMMAND_BAD_SYNTAX;
        }

        return(status);
}
예제 #7
0
void nuVertexBuffer::update(void)
{
  if(!isInitialized()) {
    CHECK_GL_ERROR(glGenBuffers(1, &mVertexBufferID));
    NU_ASSERT(mVertexBufferID != 0, "Cannot generate vertex buffer object.\n");

    CHECK_GL_ERROR(glBindBuffer(GL_ARRAY_BUFFER, mVertexBufferID));
    CHECK_GL_ERROR(glBufferData(GL_ARRAY_BUFFER, mSize, mpBuffer, getResourceUsage()));
    
    if(getUsage() == nuGResource::STATIC_RESOURCE)
      releaseBuffer();

    mCommitSize = 0;
    setInitialized(true);
  } else {
    CHECK_GL_ERROR(glBindBuffer(GL_ARRAY_BUFFER, mVertexBufferID));

    if(mCommitSize > VERTEX_BUFFER_MAP_THRESHOLD) {
      void* p_buffer;
      CHECK_GL_ERROR(p_buffer = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY));
      memcpy(p_buffer, mpBuffer, mCommitSize);
      CHECK_GL_ERROR(glUnmapBuffer(GL_ARRAY_BUFFER));
    } else {
      CHECK_GL_ERROR(glBufferSubData(GL_ARRAY_BUFFER, 0, mCommitSize, mpBuffer));
    }

    mCommitSize = 0;
  }
}
예제 #8
0
string Clocker::readResetDetailed() {
    ostringstream str;
    long dsec, usec;
    double utime, stime;
    end();
    double diff = getTimediff();
    unsigned long usage = getUsage();
    double timeUsed = usage / 1E6;

    dsec = r_usageEnd.ru_utime.tv_sec - r_usageStart.ru_utime.tv_sec;
    usec = r_usageEnd.ru_utime.tv_usec - r_usageStart.ru_utime.tv_usec;
    utime = (1000000* dsec + usec) / 1E6;

    dsec = r_usageEnd.ru_stime.tv_sec - r_usageStart.ru_stime.tv_sec;
    usec = r_usageEnd.ru_stime.tv_usec - r_usageStart.ru_stime.tv_usec;
    stime = (1000000* dsec + usec) / 1E6;

    long maxrss = r_usageEnd.ru_maxrss;
    long nvcsw = r_usageEnd.ru_nvcsw ;
    long nivcsw = r_usageEnd.ru_nivcsw;

    str << ":: " << now << " :: " << setfill('0') << setprecision(6) << setw(10) << diff << " sec elapsed";
    str << " (since " << since << ")" << endl;
    str << ":: " << now << " :: time(user) " << setfill(' ') << setprecision(4) << utime;
    str << " :: time(system) " << setfill(' ') << setprecision(4) << stime;
    str << " :: time(total) " << setfill(' ') << setprecision(4) << timeUsed;
    str << "\n:: " << now
    << " :: maxRss=" << maxrss
    << " :: cntxSwitch(user)=" << nvcsw
    << " :: cntxSwitch(forc)=" << nivcsw;

    begin();
    return str.str();
}
예제 #9
0
void Options::parseFromCommandLine(int argc, char **argv) {
    po::variables_map options;
    po::command_line_parser parser { argc, argv };

    auto usage = getUsage();
    auto positional = getPositional();
    try {
        po::store(
            parser.options(usage)
                  .positional(positional)
                  .run(),
            options
        );
        if (options.count("help")) {
            std::cerr << usage << std::endl;
            exit(0);
        }
        po::notify(options);
    }
    catch (const po::error & exception) {
        std::cerr << exception.what() << std::endl << std::endl;
        std::cerr << usage << std::endl;
        exit(1);
    }
}
예제 #10
0
static int
parseCommandLine( int argc, const char ** argv )
{
    int c;
    const char * optarg;

    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
    {
        switch( c )
        {
            case 'p': isPrivate = TRUE; break;
            case 'o': outfile = optarg; break;
            case 'c': comment = optarg; break;
            case 't': if( trackerCount + 1 < MAX_TRACKERS ) {
                          trackers[trackerCount].tier = trackerCount;
                          trackers[trackerCount].announce = (char*) optarg;
                          ++trackerCount;
                      }
                      break;
            case TR_OPT_UNK: infile = optarg; break;
            default: return 1;
        }
    }

    return 0;
}
const std::string& CmdEntityAttributeSet::execute( const std::vector< std::string >& arguments )
{
    _cmdResult = "";
    if ( arguments.size() < 3 )
    {
        _cmdResult = getUsage();
        return _cmdResult;
    }

    yaf3d::BaseEntity* p_entity = yaf3d::EntityManager::get()->findInstance( arguments[ 0 ] );
    if ( ! p_entity )
    {
        _cmdResult = "* entity instance '" + arguments[ 0 ] + "' does not exist";
        return _cmdResult;
    }

    // set attribute value using value string
    if ( !p_entity->getAttributeManager().setAttributeValueByString( arguments[ 1 ], arguments[ 2 ] ) )
    {
        _cmdResult = "* error setting attribute value, check the value format!";
    }
    else
    {
        // now send out a notification to the entity this way letting it know that we changed an attribute value
        //  the entity can decide itself if an appropriate action is necessary in this case
        yaf3d::EntityNotification notification( YAF3D_NOTIFY_ENTITY_ATTRIBUTE_CHANGED );
        yaf3d::EntityManager::get()->sendNotification( notification, p_entity );
    }

    return _cmdResult;
}
예제 #12
0
파일: d3d.cpp 프로젝트: SummersReign/SoftTH
HRESULT IDirect3DDevice9New::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle) 
{
  dbgf("dev: CreateIndexBuffer %s %s", getUsage(Usage), getPool(Pool));

  if(config.debug.compatibleIB)
  {
    // Compatible index buffer mode - do not use emulated IB, set dynamic memory instead
    if(Pool == D3DPOOL_MANAGED)
    {
      ONCE dbg("DEBUG: using compatible index buffers (manage-emulation disabled)");
      Pool = D3DPOOL_DEFAULT;
      Usage |= D3DUSAGE_DYNAMIC;
    }
    return dev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle);
  }

#if USE_D3DEX || MANAGE_DEBUG_IB
  /*if(Pool == D3DPOOL_MANAGED && Usage == D3DUSAGE_WRITEONLY)
    Pool = D3DPOOL_DEFAULT; // No need for manage-emulation for writeonly buffers, just set pool to default*/

  if(Pool == D3DPOOL_MANAGED)
  {
    *ppIndexBuffer = new IDirect3DIndexBuffer9Managed((IDirect3DDevice9Ex*)dev, this, Length, Usage, Format, Pool, pSharedHandle);
    // TODO: check for failure
    return D3D_OK;
  }
#endif
  return dev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle);
}
예제 #13
0
int KeyCommand::execute(int argc, char* argv[])
{
	int commandStatus = CommandProcessor::COMMAND_FAILED;
	if(argc == 1)
	{
		printf("\t\t\t  Shortcut Keys\n");
		printf("al ---------> addline\t\t\taacc ---------> autoaccept\n");
		printf("aans ---------> autoanswer\t\tarej ---------> autoreject\n");
		printf("cacc ---------> callaccept\t\tcans ---------> callanswer\n");
		printf("cco ---------> callconnect\t\tccr --------->callcreate\n");
		printf("cd ---------> calldestroy\t\tch ---------> callhold\n");
		printf("pf ---------> callplayfile\t\tcr ---------> callredirect\n");
		printf("si ---------> callsendinfo\t\tst ---------> callstarttone\n");
		printf("csub ---------> callsubscribe\t\tcu ---------> callunhold\n");
		printf("cfa ---------> conferenceadd\t\tcfcr ---------> conferencecreate\n");
		printf("cfd ---------> conferencedestroy\tcfgc ---------> conferencegetcalls\n");
		printf("cfh ---------> conferencehold\t\tcfj ---------> conferencejoin\n");
		printf("cfu ---------> conferenceunhold\t\tcp ---------> createpublisher\n");
		printf("dp ---------> destroypublisher\t\tup ---------> updatepublisher\n");
		printf("es ---------> enablestun\t\ter ---------> enablerport\n");
		printf("\t\t\thi ---------> history\n");
	}
	else
	{
		UtlString usage;
        getUsage(argv[0], &usage);
        printf("%s", usage.data());
        commandStatus = CommandProcessor::COMMAND_BAD_SYNTAX;
	}
	return commandStatus;
}
const std::string& CmdEntityAttributeList::execute( const std::vector< std::string >& arguments )
{
    if ( arguments.size() < 1 )
    {
        _cmdResult = getUsage();
        return _cmdResult;
    }

    _cmdResult = "list of entity attributes:\n";

    yaf3d::BaseEntity* p_entity = yaf3d::EntityManager::get()->findInstance( arguments[ 0 ] );
    if ( ! p_entity )
    {
        _cmdResult = "* entity instance '" + arguments[ 0 ] + "' does not exist";
        return _cmdResult;
    }

    std::vector< std::vector< std::string > > attributes;
    p_entity->getAttributeManager().getAttributesAsString( attributes );

    std::string info;
    std::vector< std::vector< std::string > >::iterator p_beg = attributes.begin(), p_end = attributes.end();
    for ( ; p_beg != p_end; ++p_beg )
    {
        info += ( *p_beg )[ 0 ] + "  [  " + ( *p_beg )[ 1 ] + "  ] \n";
    }
    _cmdResult = info;

    return _cmdResult;
}
예제 #15
0
static char const* getConfigDir(int argc, char const* const* argv)
{
    int c;
    char const* configDir = NULL;
    char const* optarg;
    int const ind = tr_optind;

    while ((c = tr_getopt(getUsage(), argc, argv, options, &optarg)) != TR_OPT_DONE)
    {
        if (c == 'g')
        {
            configDir = optarg;
            break;
        }
    }

    tr_optind = ind;

    if (configDir == NULL)
    {
        configDir = tr_getDefaultConfigDir(MY_NAME);
    }

    return configDir;
}
예제 #16
0
TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
    : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
{
    mTexture = NULL;
    mRenderTarget = NULL;
    // if the width or height is not positive this should be treated as an incomplete texture
    // we handle that here by skipping the d3d texture creation
    if (width > 0 && height > 0)
    {
        IDirect3DDevice9 *device = mRenderer->getDevice();
        const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat);
        d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &width, &height, &mTopLevel);
        UINT creationLevels = (levels == 0) ? 0 : mTopLevel + levels;

        HRESULT result = device->CreateTexture(width, height, creationLevels, getUsage(), d3dFormatInfo.texFormat, getPool(), &mTexture, NULL);

        if (FAILED(result))
        {
            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
            gl::error(GL_OUT_OF_MEMORY);
        }
    }

    initializeRenderTarget();
}
const std::string& CmdServerStart::execute( const std::vector< std::string >& arguments )
{
    _cmdResult = "";
    if ( arguments.size() < 1 )
    {
        _cmdResult = getUsage();
        return _cmdResult;
    }

    // get the full binary path
    std::string cmd = yaf3d::Application::get()->getFullBinPath();
    std::string levelfile = arguments[ 0 ];
    std::string arg1( "-server" );
    std::string arg2( "-level" );
    std::string arg3( levelfile );

    // use utility function to start the server
    std::string args = arg1 + "  " + arg2 + "  " + arg3;
    YAF3D_SPAWN_PROC_ID serverProcHandle = yaf3d::spawnApplication( cmd, args );

    if ( serverProcHandle )
        _cmdResult = "trying to start server with level file '" + levelfile + "'.";
    else
        _cmdResult = "* error starting server with level file '" + levelfile + "'.";

    return _cmdResult;
}
예제 #18
0
int CallSubscribeCommand::execute(int argc, char* argv[])
{
	int commandStatus = CommandProcessor::COMMAND_FAILED;
	if(argc == 4)
	{
		if(sipxCallSubscribe(atoi(argv[1]), argv[2], argv[3], subHandle)
			== SIPX_RESULT_SUCCESS)
		{
			printf("Subscription successful with call id: %d and subscription id: %d\n",
				 atoi(argv[1]), *subHandle);
		}
		else
		{
			printf("Subscription unsuccessful.\n");
		}
	}
	else
	{
		UtlString usage;
        getUsage(argv[0], &usage);
        printf("%s", usage.data());
        commandStatus = CommandProcessor::COMMAND_BAD_SYNTAX;
	}
	return commandStatus;
}
예제 #19
0
static int
parseCommandLine (int argc, const char * const * argv)
{
  int c;
  const char * optarg;

  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
    {
      switch (c)
        {
          case 'm':
            magnetFlag = true;
            break;

          case 's':
            scrapeFlag = true;
            break;

          case 'V':
            showVersion = true;
            break;

          case TR_OPT_UNK:
            filename = optarg;
            break;

          default:
            return 1;
        }
    }

    return 0;
}
예제 #20
0
int SipLogCommand::execute(int argc, char* argv[])
{
        //printf("no operation command with %d arguments\n", argc);
        //printf("exiting with status: %d\n", CommandProcessor::COMMAND_SUCCESS_EXIT);

        int commandStatus = CommandProcessor::COMMAND_FAILED;

        if(argc == 2)
        {
                UtlString logOperations(argv[1]);
        commandStatus = CommandProcessor::COMMAND_SUCCESS;

        if(logOperations.compareTo("stop") == 0)
        {
            mSipUserAgent->stopMessageLog();
            osPrintf("SIP logging Stopped\n");
        }

        else if(logOperations.compareTo("start") == 0)
        {
            mSipUserAgent->clearMessageLog();
            mSipUserAgent->startMessageLog();
            osPrintf("SIP logging Started\n");
        }

        else if(logOperations.compareTo("dump") == 0)
        {
            UtlString log;
            mSipUserAgent->getMessageLog(log);
            osPrintf("\n============>\n%s\n============>\n", log.data());
        }

        else if(logOperations.compareTo("clear") == 0)
        {
            mSipUserAgent->clearMessageLog();
            osPrintf("SIP log cleared\n");
        }

        else
        {
            argc = 1;
        }


        }

        if(argc != 2)
        {
                UtlString usage;
                getUsage(argv[0], &usage);
                printf("%s", usage.data());
                commandStatus = CommandProcessor::COMMAND_BAD_SYNTAX;
        }
        else
        {

        }

        return(commandStatus);
}
예제 #21
0
int ConferenceGetCallsCommand::execute(int argc, char* argv[])
{
	int commandStatus = CommandProcessor::COMMAND_FAILED;
	if(argc == 2)
	{
		SIPX_CALL calls[CONF_MAX_CONNECTIONS];
		size_t numCalls;
		if(sipxConferenceGetCalls(atoi(argv[1]), calls, CONF_MAX_CONNECTIONS, numCalls) ==
			SIPX_RESULT_SUCCESS)
		{
			printf("The %d call handles in the conference with id: %d are:\n", numCalls, atoi(argv[1]));
			for(unsigned int i = 0; i < numCalls; i++)
			{
				printf("%d ", calls[i]);
			}
			printf("\n");
		}
	}
	else
	{
		UtlString usage;
        getUsage(argv[0], &usage);
        printf("%s", usage.data());
        commandStatus = CommandProcessor::COMMAND_BAD_SYNTAX;
	}
	return commandStatus;
}
예제 #22
0
TextureStorage9_Cube::TextureStorage9_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
    : TextureStorage9(renderer, GetTextureUsage(internalformat, Renderer9::makeRenderer9(renderer), renderTarget))
{
    mTexture = NULL;
    for (int i = 0; i < 6; ++i)
    {
        mRenderTarget[i] = NULL;
    }

    // if the size is not positive this should be treated as an incomplete texture
    // we handle that here by skipping the d3d texture creation
    if (size > 0)
    {
        IDirect3DDevice9 *device = mRenderer->getDevice();
        int height = size;
        D3DFORMAT format = gl_d3d9::GetTextureFormat(internalformat, mRenderer);
        d3d9::MakeValidSize(false, format, &size, &height, &mTopLevel);
        UINT creationLevels = (levels == 0) ? 0 : mTopLevel + levels;

        HRESULT result = device->CreateCubeTexture(size, creationLevels, getUsage(), format, getPool(), &mTexture, NULL);

        if (FAILED(result))
        {
            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
            gl::error(GL_OUT_OF_MEMORY);
        }
    }

    initializeRenderTarget();
}
예제 #23
0
void CReactionInterface::initMapping()
{
  mpParameters = new CFunctionParameters(mpFunction->getVariables());
  //make sure mpParameters is deleted! (e.g. in copyMapping())
  mNameMap.resize(size());
  mValues.resize(size());
  mIsLocal.resize(size());
  size_t i, imax = size();

  for (i = 0; i < imax; ++i)
    {
      if (isVector(i))
        mNameMap[i].resize(0);
      else
        {
          mNameMap[i].resize(1);
          mNameMap[i][0] = "unknown";
        }

      if (getUsage(i) == CFunctionParameter::PARAMETER)
        mIsLocal[i] = true;
      else
        mIsLocal[i] = false;

      mValues[i] = 0.1;
    }
}
예제 #24
0
MojErr MojDbQuotaEngine::applyOffset(const MojString& kindId, MojInt64 offset, MojDbStorageTxn* txn)
{
	MojAssert(txn);

	// get old value
	MojRefCountedPtr<MojDbStorageItem> item;
	MojInt64 usage = 0;
	MojErr err = getUsage(kindId, txn, true, usage, item);
	MojErrCheck(err);
	if (item.get()) {
		MojInt64 newUsage = offset + usage;
		MojAssert(newUsage >= 0);
		MojObject newVal(newUsage);
		MojBuffer buf;
		err = newVal.toBytes(buf);
		MojErrCheck(err);
		// insert new record
		txn->quotaEnabled(false);
		err = m_usageDb->update(kindId, buf, item.get(), txn);
		MojErrCheck(err);
		txn->quotaEnabled(true);
	} else {
		err = insertUsage(kindId, offset, txn);
		MojErrCheck(err);
	}
	return MojErrNone;
}
const std::string& CmdShadowPolygonOffset::execute( const std::vector< std::string >& arguments )
{
    _cmdResult = "";

    if ( !arguments.size() )
    {
        _cmdResult += getUsage();
        return _cmdResult;
    }

    bool shadow;
    yaf3d::Configuration::get()->getSettingValue( YAF3D_GS_SHADOW_ENABLE, shadow );
    if ( !shadow )
    {
        _cmdResult += "dynamic shadows are not enabled! this command has no effect.";
        return _cmdResult;
    }

    if ( arguments[ 0 ] == "info" )
    {
        std::stringstream str;
        float factor = 0.0f;
        float units  = 0.0f;
        yaf3d::ShadowManager::get()->getPolygonOffset( factor, units );
        str << "factor: " << factor << " " << "units: " << units;
        _cmdResult = str.str();
        return _cmdResult;
    }
    else if ( arguments[ 0 ] == "set" )
    {
        if ( arguments.size() < 2 )
        {
            _cmdResult += getUsage();
            return _cmdResult;
        }

        std::stringstream str;
        float factor = 0.0f;
        float units  = 0.0f;
        str << arguments[ 1 ];
        str >> factor >> units;
        yaf3d::ShadowManager::get()->setPolygonOffset( factor, units );
    }
    else
    {
예제 #26
0
static int
parseCommandLine (int argc, const char ** argv)
{
  int c;
  const char * optarg;

  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
    {
      switch (c)
        {
          case 'V':
            showVersion = true;
            break;

          case 'p':
            isPrivate = true;
            break;

          case 'o':
            outfile = optarg;
            break;

          case 'c':
            comment = optarg;
            break;

          case 't':
            if (trackerCount + 1 < MAX_TRACKERS)
              {
                trackers[trackerCount].tier = trackerCount;
                trackers[trackerCount].announce = (char*) optarg;
                  ++trackerCount;
              }
            break;

          case 's':
            if (optarg) 
              { 
                char * endptr = NULL;
                piecesize_kib = strtoul (optarg, &endptr, 10);
                if (endptr && *endptr=='M')
                  piecesize_kib *= KiB; 
              }
            break;

          case TR_OPT_UNK:
            infile = optarg;
            break;

          default:
            return 1;
        }
    }

  return 0;
}
예제 #27
0
string Clocker::readReset() {
    ostringstream str;
    end();
    double diff = getTimediff();
    double timeUsed = getUsage() / 1E6;
    str << ":: " << tod(&now) << " :: " << setfill('0') << setprecision(6) << setw(10) << diff << " sec elapsed; "
    << setfill(' ') << setprecision(4) << timeUsed << " cpu sec used" ;
    begin();
    return str.str();
}
예제 #28
0
void CReactionInterface::updateModifiersInChemEq()
{
  mChemEqI.clearModifiers();
  size_t j, jmax = size();

  for (j = 0; j < jmax; ++j)
    if (getUsage(j) == CFunctionParameter::MODIFIER) //all the modifiers in the table
      if (getMapping(j) != "unknown")
        mChemEqI.addModifier(getMapping(j));
}
예제 #29
0
int main (int argc, char *argv[])
{
	static const char *args = "/dev/hidrawX page";
	auto mem_type = HIDPP20::IOnboardProfiles::MemoryType::Writeable;
	HIDPP::DeviceIndex device_index = HIDPP::DefaultDevice;

	std::vector<Option> options = {
		DeviceIndexOption (device_index),
		VerboseOption (),
		Option ('r', "rom",
			Option::NoArgument, "",
			"Read data from ROM",
			[&mem_type] (const char *) -> bool {
				mem_type = HIDPP20::IOnboardProfiles::MemoryType::ROM;
				return true;
			}),
	};
	Option help = HelpOption (argv[0], args, &options);
	options.push_back (help);

	int first_arg;
	if (!Option::processOptions (argc, argv, options, first_arg))
		return EXIT_FAILURE;

	if (argc-first_arg != 2) {
		fprintf (stderr, "%s", getUsage (argv[0], args, &options).c_str ());
		return EXIT_FAILURE;
	}

	const char *path = argv[first_arg];
	char *endptr;
	unsigned int page = strtol (argv[first_arg+1], &endptr, 0);
	if (*endptr != '\0') {
		fprintf (stderr, "Invalid page number.\n");
		return EXIT_FAILURE;
	}

	try {
		HIDPP20::Device dev (path, device_index);
		HIDPP20::IOnboardProfiles iop (&dev);
		auto desc = iop.getDescription ();
		unsigned int i = 0;
		while (i < desc.sector_size) {
			auto data = iop.memoryRead (mem_type, page, i);
			write (1, data.data (), data.size ());
			i += data.size ();
		}
	}
	catch (HIDPP20::Error e) {
		fprintf (stderr, "HID++2 error %d: %s\n", e.errorCode (), e.what ());
		return e.errorCode ();
	}

	return EXIT_SUCCESS;
}
예제 #30
0
MojErr MojDbQuotaEngine::kindUsage(const MojChar* kindId, MojInt64& usageOut, MojDbStorageTxn* txn)
{
	MojLogTrace(s_log);

	MojString kindStr;
	MojErr err = kindStr.assign(kindId);
	MojErrCheck(err);
	MojRefCountedPtr<MojDbStorageItem> item;
	err = getUsage(kindStr, txn, false, usageOut, item);
	MojErrCheck(err);

	return MojErrNone;
}