自学教程：C++ Datum函数代码示例

void MessagePackAdaptorTests::testString() {    // Empty    {        pack(Datum(""));        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::STR, o.type );        auto d = o.as<Datum>();        CPPUNIT_ASSERT( d.isString() );        CPPUNIT_ASSERT( d.stringIsCString() );        CPPUNIT_ASSERT_EQUAL( std::string(), d.getString() );    }    // Text    {        pack(Datum("abc 123"));        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::STR, o.type );        auto d = o.as<Datum>();        CPPUNIT_ASSERT( d.isString() );        CPPUNIT_ASSERT( d.stringIsCString() );        CPPUNIT_ASSERT_EQUAL( std::string("abc 123"), d.getString() );    }    // Data    {        const std::string value("/1/0/2/0/3/0", 6);        pack(Datum(value));        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::BIN, o.type );        auto d = o.as<Datum>();        CPPUNIT_ASSERT( d.isString() );        CPPUNIT_ASSERT( !d.stringIsCString() );        CPPUNIT_ASSERT_EQUAL( value, d.getString() );    }}

Datum ComponentRegistry::getNumber(std::string expression, GenericDataType type){  Datum value;    switch(type){      case M_FLOAT:      case M_INTEGER:      case M_BOOLEAN:      case M_STRING:          value = getValue(expression, type);          if (value.getDataType() == type) {              return value;          }          break;      default:          throw FatalParserException("Attempt to cast a number of invalid type");    }		switch (type){			case M_FLOAT:			return Datum(value.getFloat());		case M_INTEGER:			return Datum(value.getInteger());		case M_STRING:			return Datum(value.getString());		case M_BOOLEAN:			return Datum(value.getBool());		default:			return value;				}}

Datum ComponentRegistry::getValue(std::string expression, GenericDataType type) {  std::pair<std::string, GenericDataType> cacheKey(expression, type);  shared_ptr<Datum> test = data_cache[cacheKey];  if(test != NULL){    return *test;  }    double doubleValue;  long longValue;  bool boolValue;  Datum value;  try {    switch(type){      case M_FLOAT:      case M_INTEGER:      case M_BOOLEAN:            doubleValue = boost::lexical_cast<double>(expression);            if (M_FLOAT == type) {                value = Datum(doubleValue);            } else if (M_INTEGER == type) {                longValue = (long)doubleValue;                if ((double)longValue != doubleValue) {                                        throw NonFatalParserException("invalid integer literal", expression.c_str());                }                value = Datum(longValue);            } else {                boolValue = (bool)doubleValue;                if ((double)boolValue != doubleValue) {                                        throw NonFatalParserException("invalid boolean literal", expression.c_str());                }                value = Datum(boolValue);            }            break;      case M_STRING:          value = Datum(string(expression));          break;      default:          // No lexical_cast for other types          break;    }        if (!value.isUndefined()) {        data_cache[cacheKey] = shared_ptr<Datum>(new Datum(value));        return value;    }  } catch (NonFatalParserException& e){      // Until we work out how to effectively flag these issues, treat them as fatal errors      throw FatalParserException(e.what());  } catch (boost::bad_lexical_cast& e){    // no biggie, we can do this the hard(er) way  }    	return Datum(ParsedExpressionVariable::evaluateExpression(expression));}

Datum StimulusDisplay::getAnnounceData(bool updateIsExplicit) {    Datum stimAnnounce;        if (!shouldAnnounceStimuli(updateIsExplicit)) {        // No stim announcements, so just report the number of stimuli drawn        stimAnnounce = Datum(long(stimAnnouncements.size()));    } else {        stimAnnounce = Datum(M_LIST, int(stimAnnouncements.size()));        for (size_t i = 0; i < stimAnnouncements.size(); i++) {            stimAnnounce.addElement(stimAnnouncements[i]);        }    }    	return stimAnnounce;}

void Lingo::c_varpush() {	Common::String name((char *)&(*g_lingo->_currentScript)[g_lingo->_pc]);	Datum d;	g_lingo->_pc += g_lingo->calcStringAlignment(name.c_str());	// In immediate mode we will push variables as strings	// This is used for playAccel	if (g_lingo->_immediateMode) {		g_lingo->push(Datum(new Common::String(name)));		return;	}	if (g_lingo->getHandler(name) != NULL) {		d.type = HANDLER;		d.u.s = new Common::String(name);		g_lingo->push(d);		return;	}	d.u.sym = g_lingo->lookupVar(name.c_str());	if (d.u.sym->type == CASTREF) {		d.type = INT;		int val = d.u.sym->u.i;		delete d.u.sym;		d.u.i = val;	} else {		d.type = VAR;	}	g_lingo->push(d);}

		/** Import */		static std::auto_ptr<DHParams> Import(const std::string& dhstr)		{			std::auto_ptr<DHParams> dh(new DHParams);			int ret = gnutls_dh_params_import_pkcs3(dh->dh_params, Datum(dhstr).get(), GNUTLS_X509_FMT_PEM);			ThrowOnError(ret, "Unable to import DH params");			return dh;		}

// ScopedVariable delegate methodsDatum ScopedVariableEnvironment::getValue(int index){	if(current_context != NULL){		return current_context->get(index);	}		// TODO: warn	return Datum();}

// override of base class to provide more infoDatum DisplayBitCodeStimulus::getCurrentAnnounceDrawData() {            Datum announceData(M_DICTIONARY, 2);    announceData.addElement(STIM_NAME, getTag());        // char    announceData.addElement("bit_code",Datum((long)(*code_variable)));     return (announceData);}

void Lingo::c_symbolpush() {	char *s = (char *)&(*g_lingo->_currentScript)[g_lingo->_pc];	g_lingo->_pc += g_lingo->calcStringAlignment(s);	warning("STUB: c_symbolpush()");	// TODO: FIXME: Must push symbol instead of string	g_lingo->push(Datum(new Common::String(s)));}

void MessagePackAdaptorTests::testInteger() {    constexpr auto llmin = std::numeric_limits<long long>::min();    BOOST_STATIC_ASSERT(llmin < 0);  // Sanity check    constexpr auto llmax = std::numeric_limits<long long>::max();    BOOST_STATIC_ASSERT(llmax > 0);  // Sanity check    // Negative    {        pack(Datum(llmin));        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::NEGATIVE_INTEGER, o.type );        auto d = o.as<Datum>();        CPPUNIT_ASSERT( d.isInteger() );        CPPUNIT_ASSERT_EQUAL( llmin, d.getInteger() );    }    // Zero    {        pack(Datum(0));        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::POSITIVE_INTEGER, o.type );        auto d = o.as<Datum>();        CPPUNIT_ASSERT( d.isInteger() );        CPPUNIT_ASSERT_EQUAL( 0LL, d.getInteger() );    }    // Positive    {        pack(Datum(llmax));        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::POSITIVE_INTEGER, o.type );        auto d = o.as<Datum>();        CPPUNIT_ASSERT( d.isInteger() );        CPPUNIT_ASSERT_EQUAL( llmax, d.getInteger() );    }    // Out of bounds    {        pack(static_cast<unsigned long long>(llmax) + 1ULL);        auto o = unpack();        CPPUNIT_ASSERT_EQUAL( msgpack::type::POSITIVE_INTEGER, o.type );        CPPUNIT_ASSERT_THROW( o.as<Datum>(), msgpack::type_error );    }}

void ExpandableListTestFixture::testAddSharedPtr(){	ExpandableList<Datum> list;		shared_ptr<Datum> shared_data(new Datum(10L));	list.addElement(shared_data);		CPPUNIT_ASSERT( list.getNElements() == 1 );	CPPUNIT_ASSERT( *(list[0]) == Datum(10L) );	}

	void _makeString(const std::string &format, va_list ap, 					 MessageType type, 					 MessageDomain domain = M_GENERIC_MESSAGE_DOMAIN) {		char buffer[MSG_BUFFER_SIZE];// = { '/0' };		int length = vsnprintf(buffer, MSG_BUFFER_SIZE, format.c_str(), ap);                // If the message is a warning or an error, append line number information (if available)        if (type >= M_WARNING_MESSAGE &&            length < MSG_BUFFER_SIZE - 1)        {            boost::shared_ptr<StateSystem> stateSystem = StateSystem::instance(false);            boost::shared_ptr<State> currentState;            if (stateSystem && (currentState = stateSystem->getCurrentState().lock())) {                int currentLineNumber = currentState->getLineNumber();                if (currentLineNumber > 0) {                    snprintf(buffer + length, MSG_BUFFER_SIZE - length, " [at line %d]", currentLineNumber);                }            }        }				if (GlobalMessageVariable) {            Datum messageDatum(M_DICTIONARY, 4);            messageDatum.addElement(M_MESSAGE_DOMAIN, Datum(M_INTEGER, domain));            messageDatum.addElement(M_MESSAGE, Datum(buffer));            messageDatum.addElement(M_MESSAGE_TYPE, Datum(M_INTEGER, type));            messageDatum.addElement(M_MESSAGE_ORIGIN, Datum(M_INTEGER, GlobalMessageOrigin));                        // Use a mutex to ensure that the set and reset happen atomically            boost::lock_guard<boost::mutex> lock(globalMessageVariableMutex);            GlobalMessageVariable->setValue(messageDatum);            GlobalMessageVariable->setSilentValue(0L);		}                // For debugging:  If the environment variable MWORKS_WRITE_MESSAGES_TO_STDERR is set,        // write the message to standard error        static int echo_to_stderr = -1;        if (echo_to_stderr < 0) {            echo_to_stderr = (NULL != getenv("MWORKS_WRITE_MESSAGES_TO_STDERR"));        }        if (echo_to_stderr) {            fprintf(stderr, "%s/n", buffer);        }	}

Datum BaseFrameListStimulus::getCurrentAnnounceDrawData() {    Datum announceData = StandardDynamicStimulus::getCurrentAnnounceDrawData();        if (stimulusGroup) {        announceData.addElement(STIMULUS_GROUP, stimulusGroup->getTag());    }        announceData.addElement(LOOP, loop->getValue());    announceData.addElement("playing", Datum(isPlaying()));        int frameNumber = getFrameNumber();    announceData.addElement("current_frame", Datum((long)frameNumber));        Datum currentStimulusAnnounceData(0L);    if ((frameNumber >= 0) && (frameNumber < getNumFrames())) {        currentStimulusAnnounceData = getStimulusForFrame(frameNumber)->getCurrentAnnounceDrawData();    }    announceData.addElement("current_stimulus", currentStimulusAnnounceData);        return announceData;}

int main(){  Options o;  o.put("lon0",39.0);  o.put("E0",500000.0);  convs::pt2pt cnv(Datum("wgs84"), Proj("lonlat"), Options(),                  Datum("pulkovo"), Proj("tmerc"), o);  dPoint p( 39 + ((double)rand()/RAND_MAX - 0.5) * 6,    // 36..42                 ((double)rand()/RAND_MAX - 0.5) * 180); // -90..+90  printf("%.12f %.12f/n",p.x,p.y);  int i;  for (i=0; i<1000000; i++){    cnv.frw(p);    cnv.bck(p);  }  printf("%.12f %.12f/n",p.x,p.y);}

// returns a value "top", for which datums should be on the More side if t>=topint cisstCovTreeNode::SortNodeForSplit(){  int top = NData;  static int callNumber = 0;  callNumber++;  vct3 Ck; vct3 Ct;  vct3 r = F.Rotation().Row(0);  double px = F.Translation()[0];  for (int k = 0; k < top; k++) {    Ck = pMyTree->DatumSortPoint(Datum(k)); // 3D coordinate of datum in global coord system    double kx = r*Ck + px;  // compute the x coordinate in local coord system    if (kx > 0) { // this one needs to go to the end of the line      while ((--top) > k) {        Ct = pMyTree->DatumSortPoint(Datum(top));        double tx = r*Ct + px;        if (tx <= 0) {          int Temp = Datum(k);          Datum(k) = Datum(top);          Datum(top) = Temp;          break; // from the "top" loop        };      };	// end of the "t" loop    };	// end of the kx>0 case; at this point F*datum.x-coord <= 0 for i=0,...,k  };	// end of k loop  return top;}

void VariableTestFixture::testSimpleGlobal() {	shared_ptr<GlobalVariable>v =  global_variable_registry->createGlobalVariable( new VariableProperties(																										   new Datum(42L), "test1",																										   "Test",																										   "Test",																										   M_NEVER, M_WHEN_CHANGED,																										   true, false,																										   M_CONTINUOUS_INFINITE,""));		CPPUNIT_ASSERT((long)*v == 42);	CPPUNIT_ASSERT(v->getValue() == Datum(M_INTEGER, 42));	CPPUNIT_ASSERT(v->getVariableName() == "test1");	CPPUNIT_ASSERT(v->getLogging() == M_WHEN_CHANGED);		v->setLogging(M_NEVER);	CPPUNIT_ASSERT(v->getLogging() == M_NEVER);		v->setValue(Datum(M_INTEGER, 666));	CPPUNIT_ASSERT((long)*v == 666);		v->setValue(2112L);	CPPUNIT_ASSERT((long)*v == 2112);	}

int insertInto(vector<string> operations){	string tableName = operations[2];	vector<Datum> data;	for(int i = 5; i < operations.size(); i++){		if( isInteger(operations[i]) == true ){			int number = atoi(operations[i].c_str());			data.push_back(Datum(number));		}		else{			data.push_back(Datum(operations[i]));		}	}	engine.insertInto(tableName,data);	return 0;}

// compute the function value(s) with the current parameters//bool LinearFitableFunction::applyTheFunction(Datum *pInputData, Datum *outputData){ // DDC fixbool LinearFitableFunction::applyTheFunction(const Datum& pInputData, Datum *outputData){     lock();        if (Parameters == NULL) {        mwarning(M_SYSTEM_MESSAGE_DOMAIN,			"WARNING: Prompted for calibrated value but parameters not yet set.");        unlock(); return false;    }        //if (pInputData->getNElements() != numInputs) { // DDC fix	if (pInputData.getNElements() != numInputs) {    //        //int xxx0 = pInputData->getNElements(); // DDC fix//		int xxx0 = pInputData.getNElements();//        //double xxx1 = (double)(pInputData->getElement(0)); // DDC fix//        //double xxx2 = (double)(pInputData->getElement(1));//        double xxx1 = (double)(pInputData.getElement(0)); // DDC fix//        double xxx2 = (double)(pInputData.getElement(1));            mwarning(M_SYSTEM_MESSAGE_DOMAIN,			"WARNING: Prompted for calibrated value but not all input data exists.");        unlock(); return false;    }            double *inputDataDouble = new double [numInputs];    for (int i=0;i<numInputs;i++) {        		//inputDataDouble[i] = (double)(pInputData->getElement(i));  // copy data here // DDC fix        inputDataDouble[i] = (double)(pInputData.getElement(i));  // copy data here // DDC fix				//xxx = inputDataDouble[i];   //TODO -- remove    }        double temp = 0;    for (int p=0; p< (basisSet->getNElements()); p++) {        temp = temp + ((Parameters[p])*((basisSet->getElement(p))->applyBasis(inputDataDouble)));        //ppp = Parameters[p];    //TODO -- remove    }    *outputData = Datum(temp);//DDC edit	//*outputData = (Datum)temp;    	delete [] inputDataDouble; // DDC added	    unlock();     return true;    }