C++ checkArgs函数代码示例

//-------------------------------------------------------------------------------------
PyObject* MethodDescription::call(PyObject* func, PyObject* args)
{
	PyObject* pyResult = NULL;
	if (!PyCallable_Check(func))
	{
		PyErr_Format(PyExc_TypeError, "MethodDescription::call: method[%s] call attempted on a error object!", 
			getName());
	}
	else
	{
		if(args == NULL)
		{
			pyResult = PyObject_CallObject(func, NULL);
		}
		else
		{
			if(checkArgs(args))
				pyResult = PyObject_CallObject(func, args);
		}
	}

	if (PyErr_Occurred())
	{
		if (isExposed() && PyErr_ExceptionMatches(PyExc_TypeError))
		{
			WARNING_MSG(fmt::format("MethodDescription::call: {} is exposed of method, if there is a missing arguments error, "
				"try adding callerEntityID, For example: \ndef func(msg): => def func(callerEntityID, msg):\n",
				this->getName()));
		}

		PyErr_PrintEx(0);
	}

	return pyResult;
}

int main  ( int argc, char **argv ) {
	double time_spent;
	struct timeval  tv1, tv2;
#ifdef DEBUG
	printf("IN MAIN\n");
#endif
	/*Displays Help Command*/

	if(argc!=MIN_REQUIRED) {	help("WRONG NUMBER OF ARGUMENTS");}
	if(!strcmp(argv[1], "-h")){	help("HELP: ");}
	if(argc == 2){	checkArgs(argv[1]);}
	gettimeofday(&tv1, NULL);

	readFile(argv[1]);
	populateMemory();
	readMemory();
	gettimeofday(&tv2, NULL);

	/*printf("%x", 0x3f%0x10);*/
	time_spent= (double)(tv2.tv_usec - tv1.tv_usec)/1000000 + (double)(tv2.tv_sec - tv1.tv_sec);
	printf("\n=========\n TIME REQUIRED: %.0f microseconds\n=========\n", time_spent* 1000000);
#ifdef DEBUG
	printf("OUT OF MAIN\n");
#endif
	return 0;
}

int _tmain(int argc, char* argv[])
{
	char *inFile = NULL;
	outFormat format = NOTSET;
	int rowStart = -1;
	int rowEnd = -1;
	packets parsedList;

#ifdef _DEBUG
	testparseQueryString();
	testParseFile();
#endif

	printf("Content-Type: text/xml\n\n");

	if (!checkArgs(argc, argv, &inFile, format, rowStart, rowEnd))
	{
		printUsage();
		return -1;
	}

	parseFile(inFile, rowStart, rowEnd, parsedList);

	outputInfo(parsedList, format);

	return 0;
}

int main(int argc, char** argv) {

    checkArgs(argc, argv);
    copyFile(argv[1], argv[2]);

    return 0;
}

void GlobalArgsTabu::retrieve(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "m:o:t:r:f:")) != -1) {
        switch(opt) {
            case 'm':
                ttIterationsWoModification = std::stoul(optarg);
                break;
            
            case 'o':
                maxOccurencesFrequentlyEncountered = std::stoul(optarg);
                break;
            
            case 't':
                maxCandidateTriggerEscape = std::stoul(optarg);
                break;
            
            case 'r':
                randomStepsEscape = std::stoul(optarg);
                break;
            
            case 'f':
                filePath = optarg;
                break;
            
            default:
                break;
        }
    }

    checkArgs();
}

/*
	Main method.
*/
int main(int argc, char *argv[])
{
	/* Hexadecimal, Octal, Character, Hexadecimal and ASCII, Length, Offset */
	int optionFlags[] = {ON, OFF, OFF, OFF, OFF, OFF};
	
	/* Length bytes of input to interpret, Offset bytes from beginning */
	int optionValues[] = {0, 0};
	
	int *flags = optionFlags;
	int *values = optionValues;
	int i = 1;
	int checkArgsValidation = 0;
	
	if(argv[1] == NULL)
	{
		printf("No arguments specified. Qutting program...\n");
		
		return 1;
	}
	
	for(i = 1; i < argc; i++)
	{	
		checkArgsValidation = checkArgs(i, argv, flags, values);
	
		if(checkArgsValidation == 0)
		{
			break;
		}
	}
	
	return 0;
}

int main  ( int argc, char **argv ) {
	double time_spent;
	struct timeval  tv1, tv2;
#ifdef DEBUG
	printf("IN MAIN\n");
#endif
	/*Check Arguments*/
	if(argc!=MIN_REQUIRED)	help("WRONG NUMBER OF ARGUMENTS");
	if(!strcmp(argv[1], "-h"))	help("HELP: ");
	if(argc == 2)	checkArgs(argv[1]);
	/*Tracks time*/
	gettimeofday(&tv1, NULL);
	/*Reads File and Populates Data*/
	readFile( argv[1]);
	/*Populates Memory*/
	populateMemory();
	/*Runs through fetch decode execute loop*/
	readMemory();
	/*Tracks time*/
	gettimeofday(&tv2, NULL);

	time_spent= (double)(tv2.tv_usec - tv1.tv_usec)/1000000 + (double)(tv2.tv_sec - tv1.tv_sec);
	printf("\n=========\n TIME REQUIRED: %.0f microseconds\n=========\n", time_spent* 1000000);
#ifdef DEBUG
	printf("OUT OF MAIN\n");
#endif
	return 0;
}

CMPIBoolean __eft_evaluateUsingAccessor (
    CONST CMPISelectExp* se,
    CMPIAccessor *accessor, 
    void *parm, CMPIStatus* rc)
{
    CMPIContext *ctx;
    CMPIBroker *broker;

    if (!checkArgs(se, rc) || !checkArgs(accessor, rc))
    {
        return 0;
    }
    broker = tool_mm_get_broker ( (void**)&ctx);
    return( ( (NativeCMPIBrokerFT*)broker->bft) )->
        selExp_evaluateUsingAccessor (se, accessor ,parm, rc);
}

CMPIBoolean __eft_evaluate ( 
    CONST CMPISelectExp * exp,
    CONST CMPIInstance * inst,
    CMPIStatus * rc )
{
    CMPIContext *ctx;
    CMPIBroker *broker;

    if (!checkArgs(exp, rc) || !checkArgs(inst, rc))
    {
        return 0;
    }
    broker = tool_mm_get_broker ( (void**)&ctx);

    return(((NativeCMPIBrokerFT*)broker->bft))->selExp_evaluate (exp, inst ,rc);
}

Value testingGradient_AST(argList *a) {
	checkArgs(a, 0);
	long long numFrames = (long long)OPTNUM("frames", 1000);
	long long width = (long long)OPTNUM("width", 200);
	long long height = (long long)OPTNUM("height", 200);

	////////////////////
	// Error Checking //
	////////////////////
	if(numFrames < 0 || width < 0 || height < 0)
		MkvsynthError("width, height, and frames must be numbers greater than 0");

	MkvsynthOutput *output = createOutputBuffer();

	///////////////
	// Meta Data //
	///////////////
	output->metaData->colorspace = MKVS_RGB48;
	output->metaData->width = width;
	output->metaData->height = height;
	output->metaData->fpsNumerator = 60;
	output->metaData->fpsDenominator = 1;

	////////////////////////
	// Pthread Parameters //
	////////////////////////
	struct TestingGradientParams *params = malloc(sizeof(struct TestingGradientParams));
	params->frames = numFrames;
	params->output = output;

	mkvsynthQueue((void *)params, testingGradient);

	RETURNCLIP(output);
}

// H=gradHist(M,O,[...]) - see gradientHist.m
void mGradHist( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) {
  int h, w, d, hb, wb, nChns, binSize, nOrients, softBin, useHog;
  bool full; float *M, *O, *H, clipHog;
  checkArgs(nl,pl,nr,pr,1,3,2,8,&h,&w,&d,mxSINGLE_CLASS,(void**)&M);
  O = (float*) mxGetPr(pr[1]);
  if( mxGetM(pr[1])!=h || mxGetN(pr[1])!=w || d!=1 ||
    mxGetClassID(pr[1])!=mxSINGLE_CLASS ) mexErrMsgTxt("M or O is bad.");
  binSize  = (nr>=3) ? (int)   mxGetScalar(pr[2])    : 8;
  nOrients = (nr>=4) ? (int)   mxGetScalar(pr[3])    : 9;
  softBin  = (nr>=5) ? (int)   mxGetScalar(pr[4])    : 1;
  useHog   = (nr>=6) ? (int)   mxGetScalar(pr[5])    : 0;
  clipHog  = (nr>=7) ? (float) mxGetScalar(pr[6])    : 0.2f;
  full     = (nr>=8) ? (bool) (mxGetScalar(pr[7])>0) : false;
  hb = h/binSize; wb = w/binSize;
  nChns = useHog== 0 ? nOrients : (useHog==1 ? nOrients*4 : nOrients*3+5);
  pl[0] = mxCreateMatrix3(hb,wb,nChns,mxSINGLE_CLASS,1,(void**)&H);
  if( nOrients==0 ) return;
  if( useHog==0 ) {
    gradHist( M, O, H, h, w, binSize, nOrients, softBin, full );
  } else if(useHog==1) {
    hog( M, O, H, h, w, binSize, nOrients, softBin, full, clipHog );
  } else {
    fhog( M, O, H, h, w, binSize, nOrients, softBin, clipHog );
  }
}

 /** Searches for a config file in the command-line arguments,
  * environment, and finally in a default location.  WARNING:
  * if no valid config file is found, the value of the result
  * parameter is unspecified!  Always make sure to check the return
  * value!
  * @param argc Argument count
  * @param argv Argument list
  * @param result std::string reference to store the path, if any
  * @return true if a config file is found, false otherwise.
  */
 bool findConfigFile(int argc, char** argv, string& result)
 {
   if      ( checkArgs(argc, argv, result) ) return true;
   else if ( checkEnv(result) ) return true;
   else if ( checkDefault(result) ) return true;
   else return false;
 }

int main(int args, char *argv[]){
  
  int option = checkArgs(args, argv);
  int returnVal = 0;
  switch (option){
    case 1:{ //-review
        XmElem *top = openXmElemTree( stdin );
        if (top == NULL){
          return EXIT_FAILURE;
        }
        returnVal = review(top, stdout);
        mxCleanElem (top);
      break;
    }
    case 2:{ //-cat
      returnVal = combineFiles(args, argv, stdout);
      break;
    }
    case 3:{ //-keep 
      XmElem *top = openXmElemTree( stdin );
      if (top == NULL){
        return EXIT_FAILURE;
      }
      returnVal = selects(top, KEEP, argv[2], stdout);
      mxCleanElem(top);
      break;
    }
    case 4:{ //-discard
      XmElem *top = openXmElemTree( stdin );
      if (top == NULL){
        return EXIT_FAILURE;
      }
      returnVal = selects(top, DISCARD, argv[2], stdout);
      mxCleanElem(top);
      break;
    }
    case 5:{ //-lib
      XmElem *top = openXmElemTree( stdin );
      if (top == NULL){
        return EXIT_FAILURE;
      }
      returnVal = libFormat(top, stdout);
      mxCleanElem(top);
      break;
    }
    case 6:{ //-bib
      XmElem *top = openXmElemTree( stdin );
      if (top == NULL){
        return EXIT_FAILURE;
      }
      returnVal = bibFormat(top, stdout);
      mxCleanElem(top);
      break;
    }
    default://invalid command 
      return EXIT_FAILURE;
  }
  
  return returnVal;
}

TEST_F( Factory_TEST
      , StoreAndGetObjectWithAGroupWith2Params__ObjectToStoreAndGetAreEqual )
{
    typedef Factory< Models::IModel
                   , int
                   , int > ModelFactory2;

    EXPECT_CALL( *model__
               , checkArgs( 3
                          , 2 ) );

    std::shared_ptr< int > int_ptr_1( new int( 3 ) );
    std::shared_ptr< int > int_ptr_2( new int( 2 ) );

    ModelFactory2::store( "tt2"
                        , "testArgs2"
                        , Models::MockModel::createMockModelWithArg );

    std::shared_ptr< Models::IModel > returned_object =
                                      ModelFactory2::get( "tt2"
                                                        , "testArgs2"
                                                        , int_ptr_1
                                                        , int_ptr_2 );

    EXPECT_EQ( static_cast< Models::IModel* >( model__ )
             , returned_object.get() );
}

int main(int argc, char* argv[]){
   //Check Command line arguments
   if(checkArgs(argc, argv)){
      return -1;
   }

   //Create new inetSock from portNumber argument
   inetSock servSock(argv[1]);
   
   //Sets listening socket to non-blocking  
//   fcntl(servSock.getFileDescriptor(), F_SETFL, O_NONBLOCK);

   std::string servHandle = getHandle();

   //Listen on file descriptor
   listen(servSock.getFileDescriptor(), QUEUE_LENGTH);	 //QUEUE_LENGTH macro defined

   //Client/connection information
   std::vector< std::pair<std::string, inetSock> > clients;

   int tempFD;
   struct sockaddr_in tempAddr;
   socklen_t tempLen = sizeof(struct sockaddr_in);

   while(1){
      std::cout << "Waiting on peer connection..." << std::endl;
      tempFD = accept(servSock.getFileDescriptor(), (struct sockaddr*)&tempAddr, &tempLen);
      if(errno != EWOULDBLOCK && errno != EAGAIN){
	 fcntl(tempFD, F_SETFL, fcntl(tempFD, F_GETFL) & (~O_NONBLOCK));
	 chatProcess(tempFD, servHandle);
      } 
   }

   return 0;
}