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

	void handle_read(ranger::event::tcp_connection& conn, ranger::event::buffer&& buf) {		std::vector<char> v(buf.size());		buf.remove(v.data(), v.size());		for (auto ch: v) std::cout << ch << std::flush;		conn.write_buffer().append(v.data(), v.size());	}

			/**			 * The method returns the measurement noise vector.			 *			 * /return The process noise.			 */			inline const vector& calculateV()			{				for(size_t i=0; i<ngV.size(); ++i) 	v(i) = (*ngV[i])();				return v;			}

Estimate Estimate::operator << (i32 howmuch) const{    LongFloat v(m_Value << howmuch);    return Estimate(v, (m_Error << howmuch) + RoundingError(v, v.AdditionRoundingError()));}

/// Multiply a vector by scalar./// /param a a scalar.template < typename T > vector < T > vector < T >::operator*(T a) const {    vector < T > v(this->m_rows);    for (int i = this->m_rows - 1; i >= 0; i--)        v.p[i] = a * this->p[i];    return v;}

inline Vector<DIM, T> Vector<DIM, T>::normalized() const{	Vector<DIM, T> v(*this);	v.normalize();	return v;}

const var& var::operator= (const String& newValue)            { var v (newValue); swapWith (v); return *this; }

/*************************************************************************Obsolete 1-based subroutine.See RMatrixBDMultiplyByQ for 0-based replacement.*************************************************************************/void multiplybyqfrombidiagonal(const ap::real_2d_array& qp,     int m,     int n,     const ap::real_1d_array& tauq,     ap::real_2d_array& z,     int zrows,     int zcolumns,     bool fromtheright,     bool dotranspose){    int i;    int ip1;    int i1;    int i2;    int istep;    ap::real_1d_array v;    ap::real_1d_array work;    int vm;    int mx;    if( m<=0||n<=0||zrows<=0||zcolumns<=0 )    {        return;    }    ap::ap_error::make_assertion(fromtheright&&zcolumns==m||!fromtheright&&zrows==m, "MultiplyByQFromBidiagonal: incorrect Z size!");        //    // init    //    mx = ap::maxint(m, n);    mx = ap::maxint(mx, zrows);    mx = ap::maxint(mx, zcolumns);    v.setbounds(1, mx);    work.setbounds(1, mx);    if( m>=n )    {                //        // setup        //        if( fromtheright )        {            i1 = 1;            i2 = n;            istep = +1;        }        else        {            i1 = n;            i2 = 1;            istep = -1;        }        if( dotranspose )        {            i = i1;            i1 = i2;            i2 = i;            istep = -istep;        }                //        // Process        //        i = i1;        do        {            vm = m-i+1;            ap::vmove(v.getvector(1, vm), qp.getcolumn(i, i, m));            v(1) = 1;            if( fromtheright )            {                applyreflectionfromtheright(z, tauq(i), v, 1, zrows, i, m, work);            }            else            {                applyreflectionfromtheleft(z, tauq(i), v, i, m, 1, zcolumns, work);            }            i = i+istep;        }        while(i!=i2+istep);    }    else    {                //        // setup        //        if( fromtheright )        {            i1 = 1;            i2 = m-1;            istep = +1;        }        else        {            i1 = m-1;//.........这里部分代码省略.........

int main(int, char**) {    int failed = 0;    // Basic AMQP types    RUN_TEST(failed, simple_type_test(null()));    RUN_TEST(failed, simple_type_test(false));    RUN_TEST(failed, simple_type_test(uint8_t(42)));    RUN_TEST(failed, simple_type_test(int8_t(-42)));    RUN_TEST(failed, simple_type_test(uint16_t(4242)));    RUN_TEST(failed, simple_type_test(int16_t(-4242)));    RUN_TEST(failed, simple_type_test(uint32_t(4242)));    RUN_TEST(failed, simple_type_test(int32_t(-4242)));    RUN_TEST(failed, simple_type_test(uint64_t(4242)));    RUN_TEST(failed, simple_type_test(int64_t(-4242)));    RUN_TEST(failed, simple_type_test(wchar_t('X')));    RUN_TEST(failed, simple_type_test(float(1.234)));    RUN_TEST(failed, simple_type_test(double(11.2233)));    RUN_TEST(failed, simple_type_test(timestamp(1234)));    RUN_TEST(failed, simple_type_test(make_fill<decimal32>(0)));    RUN_TEST(failed, simple_type_test(make_fill<decimal64>(0)));    RUN_TEST(failed, simple_type_test(make_fill<decimal128>(0)));    RUN_TEST(failed, simple_type_test(uuid::copy("/x00/x11/x22/x33/x44/x55/x66/x77/x88/x99/xaa/xbb/xcc/xdd/xee/xff")));    RUN_TEST(failed, simple_type_test(std::string("xxx")));    RUN_TEST(failed, simple_type_test(symbol("aaa")));    RUN_TEST(failed, simple_type_test(binary("aaa")));    // Native int type that may map differently per platform to uint types.    RUN_TEST(failed, simple_type_test(char(42)));    RUN_TEST(failed, simple_type_test(short(42)));    RUN_TEST(failed, simple_type_test(int(42)));    RUN_TEST(failed, simple_type_test(long(42)));    RUN_TEST(failed, simple_type_test(static_cast<signed char>(42)));    RUN_TEST(failed, simple_type_test(static_cast<signed short>(42)));    RUN_TEST(failed, simple_type_test(static_cast<signed int>(42)));    RUN_TEST(failed, simple_type_test(static_cast<signed long>(42)));    RUN_TEST(failed, simple_type_test(static_cast<unsigned char>(42)));    RUN_TEST(failed, simple_type_test(static_cast<unsigned short>(42)));    RUN_TEST(failed, simple_type_test(static_cast<unsigned int>(42)));    RUN_TEST(failed, simple_type_test(static_cast<unsigned long>(42)));#if PN_CPP_HAS_LONG_LONG_TYPE    RUN_TEST(failed, simple_type_test(static_cast<long long>(42)));    RUN_TEST(failed, simple_type_test(static_cast<signed long long>(42)));    RUN_TEST(failed, simple_type_test(static_cast<unsigned long long>(42)));#endif    // value and scalar types, more tests in value_test and scalar_test.    RUN_TEST(failed, simple_type_test(value("foo")));    RUN_TEST(failed, value v(23); simple_type_test(v));    RUN_TEST(failed, simple_type_test(scalar(23)));    RUN_TEST(failed, simple_type_test(annotation_key(42)));    RUN_TEST(failed, simple_type_test(message_id(42)));    // Make sure we reject uncodable types    RUN_TEST(failed, (uncodable_type_test<std::pair<int, float> >()));    RUN_TEST(failed, (uncodable_type_test<std::pair<scalar, value> >()));    RUN_TEST(failed, (uncodable_type_test<std::basic_string<wchar_t> >()));    RUN_TEST(failed, (uncodable_type_test<internal::data>()));    RUN_TEST(failed, (uncodable_type_test<pn_data_t*>()));    return failed;}

/*************************************************************************Multiplication by matrix P which reduces matrix A to  bidiagonal form.The algorithm allows pre- or post-multiply by P or P'.Input parameters:    QP          -   matrices Q and P in compact form.                    Output of RMatrixBD subroutine.    M           -   number of rows in matrix A.    N           -   number of columns in matrix A.    TAUP        -   scalar factors which are used to form P.                    Output of RMatrixBD subroutine.    Z           -   multiplied matrix.                    Array whose indexes range within [0..ZRows-1,0..ZColumns-1].    ZRows       -   number of rows in matrix Z. If FromTheRight=False,                    ZRows=N, otherwise ZRows can be arbitrary.    ZColumns    -   number of columns in matrix Z. If FromTheRight=True,                    ZColumns=N, otherwise ZColumns can be arbitrary.    FromTheRight -  pre- or post-multiply.    DoTranspose -   multiply by P or P'.Output parameters:    Z - product of Z and P.                Array whose indexes range within [0..ZRows-1,0..ZColumns-1].                If ZRows=0 or ZColumns=0, the array is not modified.  -- ALGLIB --     Copyright 2005-2007 by Bochkanov Sergey*************************************************************************/void rmatrixbdmultiplybyp(const ap::real_2d_array& qp,     int m,     int n,     const ap::real_1d_array& taup,     ap::real_2d_array& z,     int zrows,     int zcolumns,     bool fromtheright,     bool dotranspose){    int i;    ap::real_1d_array v;    ap::real_1d_array work;    int mx;    int i1;    int i2;    int istep;    if( m<=0||n<=0||zrows<=0||zcolumns<=0 )    {        return;    }    ap::ap_error::make_assertion(fromtheright&&zcolumns==n||!fromtheright&&zrows==n, "RMatrixBDMultiplyByP: incorrect Z size!");        //    // init    //    mx = ap::maxint(m, n);    mx = ap::maxint(mx, zrows);    mx = ap::maxint(mx, zcolumns);    v.setbounds(0, mx);    work.setbounds(0, mx);    v.setbounds(0, mx);    work.setbounds(0, mx);    if( m>=n )    {                //        // setup        //        if( fromtheright )        {            i1 = n-2;            i2 = 0;            istep = -1;        }        else        {            i1 = 0;            i2 = n-2;            istep = +1;        }        if( !dotranspose )        {            i = i1;            i1 = i2;            i2 = i;            istep = -istep;        }                //        // Process        //        if( n-1>0 )        {            i = i1;            do            {                ap::vmove(&v(1), &qp(i, i+1), ap::vlen(1,n-1-i));                v(1) = 1;                if( fromtheright )//.........这里部分代码省略.........

/*************************************************************************Obsolete 1-based subroutine.See RMatrixBDUnpackQ for 0-based replacement.*************************************************************************/void unpackqfrombidiagonal(const ap::real_2d_array& qp,     int m,     int n,     const ap::real_1d_array& tauq,     int qcolumns,     ap::real_2d_array& q){    int i;    int j;    int ip1;    ap::real_1d_array v;    ap::real_1d_array work;    int vm;    ap::ap_error::make_assertion(qcolumns<=m, "UnpackQFromBidiagonal: QColumns>M!");    if( m==0||n==0||qcolumns==0 )    {        return;    }        //    // init    //    q.setbounds(1, m, 1, qcolumns);    v.setbounds(1, m);    work.setbounds(1, qcolumns);        //    // prepare Q    //    for(i = 1; i <= m; i++)    {        for(j = 1; j <= qcolumns; j++)        {            if( i==j )            {                q(i,j) = 1;            }            else            {                q(i,j) = 0;            }        }    }    if( m>=n )    {        for(i = ap::minint(n, qcolumns); i >= 1; i--)        {            vm = m-i+1;            ap::vmove(v.getvector(1, vm), qp.getcolumn(i, i, m));            v(1) = 1;            applyreflectionfromtheleft(q, tauq(i), v, i, m, 1, qcolumns, work);        }    }    else    {        for(i = ap::minint(m-1, qcolumns-1); i >= 1; i--)        {            vm = m-i;            ip1 = i+1;            ap::vmove(v.getvector(1, vm), qp.getcolumn(i, ip1, m));            v(1) = 1;            applyreflectionfromtheleft(q, tauq(i), v, i+1, m, 1, qcolumns, work);        }    }}

/*************************************************************************Obsolete 1-based subroutine.See RMatrixBDUnpackPT for 0-based replacement.*************************************************************************/void unpackptfrombidiagonal(const ap::real_2d_array& qp,     int m,     int n,     const ap::real_1d_array& taup,     int ptrows,     ap::real_2d_array& pt){    int i;    int j;    int ip1;    ap::real_1d_array v;    ap::real_1d_array work;    int vm;    ap::ap_error::make_assertion(ptrows<=n, "UnpackPTFromBidiagonal: PTRows>N!");    if( m==0||n==0||ptrows==0 )    {        return;    }        //    // init    //    pt.setbounds(1, ptrows, 1, n);    v.setbounds(1, n);    work.setbounds(1, ptrows);        //    // prepare PT    //    for(i = 1; i <= ptrows; i++)    {        for(j = 1; j <= n; j++)        {            if( i==j )            {                pt(i,j) = 1;            }            else            {                pt(i,j) = 0;            }        }    }    if( m>=n )    {        for(i = ap::minint(n-1, ptrows-1); i >= 1; i--)        {            vm = n-i;            ip1 = i+1;            ap::vmove(&v(1), &qp(i, ip1), ap::vlen(1,vm));            v(1) = 1;            applyreflectionfromtheright(pt, taup(i), v, 1, ptrows, i+1, n, work);        }    }    else    {        for(i = ap::minint(m, ptrows); i >= 1; i--)        {            vm = n-i+1;            ap::vmove(&v(1), &qp(i, i), ap::vlen(1,vm));            v(1) = 1;            applyreflectionfromtheright(pt, taup(i), v, 1, ptrows, i, n, work);        }    }}

int main(){    quan::velocity::m_per_s      v(1);    v += 20;}

int main(){	{		boost::shared_ptr<int> sp(new int(10));		assert(sp.unique());		boost::shared_ptr<int> sp2 = sp;		assert(sp == sp2 && sp.use_count() == 2);		*sp2 = 100;		assert(*sp == 100);		sp.reset();		assert(!sp);		boost::shared_ptr<int> p(new int(100));		shared s1(p), s2(p);		s1.print();		s2.print();		*p = 20;		print_func(p);		s1.print();	}	{		//factory function		//template<class T,class... Args>		//boost::shared_ptr<T> boost::make_shared(Args && ... args);		boost::shared_ptr<std::string> sp = 			boost::make_shared<std::string>("make_shared");		boost::shared_ptr<std::vector<int> > spv =			boost::make_shared<std::vector<int> >(10,2);		assert(spv->size() == 10);	}	{		typedef std::vector<boost::shared_ptr<int> > vs;		vs v(10);		int i = 0;		for(vs::iterator pos=v.begin();pos!=v.end();++pos)		{			(*pos) = boost::make_shared<int>(++i);			std::cout << *(*pos) << ", ";		}		std::cout << std::endl;		boost::shared_ptr<int> p = v[9];		*p = 100;		std::cout << *v[9] << std::endl;		for(auto& ptr : v)		{			ptr = boost::make_shared<int>(++i);			std::cout << *ptr << ", ";		}		std::cout << std::endl;	}	{		//bridge pattern		sample s;		s.print();	}	return 0;}

void SaveLimits(Robot& robot,const TimeScaledBezierCurve& traj,Real dt,const char* fn){  Real T=traj.EndTime();  int numdivs = (int)Ceil(T/dt);  printf("Saving time-scaled values to %s/n",fn);  ofstream out(fn,ios::out);  out<<"t";  for(size_t i=0;i<robot.links.size();i++)    out<<",q["<<robot.linkNames[i]<<"]";  for(size_t i=0;i<robot.links.size();i++)    out<<",v["<<robot.linkNames[i]<<"]";  for(size_t i=0;i<robot.links.size();i++)    out<<",a["<<robot.linkNames[i]<<"]";  out<<",activeVLimit,activeAlimit,vsaturation,asaturation";  out<<endl;  Vector q,v,a,maxv,maxa;  for(int i=0;i<=numdivs;i++) {    //double-checking velocity and acceleration bounds    Real t = Real(i)/Real(numdivs)*T;    traj.Eval(t,q);    traj.Deriv(t,v);    traj.Accel(t,a);    out<<t;    for(int j=0;j<q.n;j++)      out<<","<<q(j);    for(int j=0;j<v.n;j++)      out<<","<<v(j);    for(int j=0;j<a.n;j++)      out<<","<<a(j);    Real maxVSat=0,maxASat=0;    int maxVSatInd=0,maxASatInd=0;    for(int j=0;j<v.n;j++)      if(Abs(v(j))/robot.velMax(j) > maxVSat) {	maxVSat = Abs(v(j))/robot.velMax(j);	maxVSatInd = j;      }    for(int j=0;j<a.n;j++)      if(Abs(a(j))/robot.accMax(j) > maxASat) {	maxASat = Abs(a(j))/robot.accMax(j);	maxASatInd = j;      }    out<<","<<robot.linkNames[maxVSatInd];    out<<","<<robot.linkNames[maxASatInd];    out<<","<<maxVSat<<","<<maxASat<<endl;  }  out<<endl;  for(size_t i=0;i<traj.timeScaling.times.size();i++) {    //double-checking velocity and acceleration bounds    Real t = traj.timeScaling.times[i];    traj.Eval(t,q);    traj.Deriv(t,v);    traj.Accel(t,a);    out<<t;    for(int j=0;j<q.n;j++)      out<<","<<q(j);    for(int j=0;j<v.n;j++)      out<<","<<v(j);    for(int j=0;j<a.n;j++)      out<<","<<a(j);    Real maxSat=0;    int maxSatInd=0;    bool maxSatA=false;    for(int j=0;j<v.n;j++)      if(Abs(v(j))/robot.velMax(j) > maxSat) {	maxSat = Abs(v(j))/robot.velMax(j);	maxSatInd = j;      }    for(int j=0;j<a.n;j++)      if(Abs(a(j))/robot.accMax(j) > maxSat) {	maxSat = Abs(a(j))/robot.accMax(j);	maxSatInd = j;	maxSatA=true;      }    if(maxSatA)      out<<",a["<<robot.linkNames[maxSatInd]<<"]";    else      out<<",v["<<robot.linkNames[maxSatInd]<<"]";    out<<","<<maxSat<<endl;  }}

int main(int argc, char *argv[]) {  int time_limit;  char name[1000];  ListGraph g;  EdgeWeight lpvar(g);  EdgeWeight weight(g);  NodeName vname(g);  ListGraph::NodeMap<double> posx(g),posy(g);  string filename;  int seed=1;  // uncomment one of these lines to change default pdf reader, or insert new one  //set_pdfreader("open");    // pdf reader for Mac OS X  //set_pdfreader("xpdf");    // pdf reader for Linux  //set_pdfreader("evince");  // pdf reader for Linux  srand48(seed);  time_limit = 3600; // solution must be obtained within time_limit seconds  if (argc!=2) {cout<< endl << "Usage: "<< argv[0]<<" <graph_filename>"<<endl << endl <<      "Example: " << argv[0] << " gr_berlin52" << endl <<      "         " << argv[0] << " gr_att48" << endl << endl; exit(0);}    else if (!FileExists(argv[1])) {cout<<"File "<<argv[1]<<" does not exist."<<endl; exit(0);}  filename = argv[1];    // Read the graph  if (!ReadListGraph(filename,g,vname,weight,posx,posy))     {cout<<"Error reading graph file "<<argv[1]<<"."<<endl;exit(0);}  TSP_Data tsp(g,vname,posx,posy,weight);   ListGraph::EdgeMap<GRBVar> x(g);  GRBEnv env = GRBEnv();  GRBModel model = GRBModel(env);#if GUROBI_NEWVERSION  model.getEnv().set(GRB_IntParam_LazyConstraints, 1);  model.getEnv().set(GRB_IntParam_Seed, seed);#else  model.getEnv().set(GRB_IntParam_DualReductions, 0); // Dual reductions must be disabled when using lazy constraints#endif  model.set(GRB_StringAttr_ModelName, "Emparelhamento perfeito with GUROBI");  // name to the problem  model.set(GRB_IntAttr_ModelSense, GRB_MAXIMIZE); // is a minimization problem    // Add one binary variable for each edge and also sets its cost in  //the objective function  for (ListGraph::EdgeIt e(g); e!=INVALID; ++e) {    sprintf(name,"x_%s_%s",vname[g.u(e)].c_str(),vname[g.v(e)].c_str());    x[e] = model.addVar(0.0, 1.0, weight[e],GRB_BINARY,name);  }  model.update(); // run update to use model inserted variables  // Add degree constraint for each node (sum of solution edges incident to a node is 2)  for (ListGraph::NodeIt v(g); v!=INVALID; ++v) {    GRBLinExpr expr;    for (ListGraph::IncEdgeIt e(g,v); e!=INVALID; ++e) expr += x[e];    //aqui model.addConstr(expr == 2 ); what? ignorou!    model.addConstr(expr == 1);  }  try {    model.update(); // Process any pending model modifications.    if (time_limit >= 0) model.getEnv().set(GRB_DoubleParam_TimeLimit,time_limit);    model.update(); // Process any pending model modifications.    model.write("model.lp");    system("cat model.lp");    model.optimize();    double soma=0.0;    int i = 0;    for (ListGraph::EdgeIt e(g); e!=INVALID; ++e) {      lpvar[e] = x[e].get(GRB_DoubleAttr_X);      if (lpvar[e] > 1-BC_EPS ) {	soma += weight[e];	cout << "Achei, x("<< vname[g.u(e)] << " , " << vname[g.v(e)] << ") = " << lpvar[e] <<"/n";	tsp.BestCircuit[i] = g.u(e);	tsp.BestCircuit[i+1] = g.v(e);	i = i+2;	      }    }    cout << "Solution cost = "<< soma << endl;    ViewTspCircuit(tsp);  }catch (...) {    if (tsp.BestCircuitValue < DBL_MAX) {      cout << "Heuristic obtained optimum solution"  << endl;      ViewTspCircuit(tsp);      return 0;    }else {      cout << "Graph is infeasible"  << endl;      return 1;    }  }}

	static std::vector<std::complex<double>> vector(gsl_vector_complex *p){		std::vector<std::complex<double>> v(p->size);		for(size_t i=0; i<v.size(); i++) v[i] = std::complex<double>(GSL_VECTOR_REAL(p, i), GSL_VECTOR_IMAG(p, i));		return v;}

//---	get stl contener matrix from gsl_matrix	---	static std::vector<std::vector<double>> (gsl_matrix *p){		std::vector<std::vector<double>> v(p.size2);		for(size_t i=0; i<v.size(); i++) v[i] = gsl_permutation_get(p, i);		return v;}

void test01(const T& x){    CIMValue v(x);    CIMValue v2(v);    CIMValue v3;    // Create a null constructor    CIMType type = v.getType();            // get the type of v    CIMValue v4(type,false);    v3 = v2;    CIMValue v5;    v5 = v4;#ifdef IO    if (verbose)    {	cout << "/n----------------------/n";	XmlWriter::printValueElement(v3, cout);    }#endif    try    {        T t;        v3.get(t);        assert (!v.isNull());        assert (!v.isArray());        assert (!v2.isNull());        assert(t == x);        assert (v3.typeCompatible(v2));        // Confirm that the constructor created Null, not array and correct type        assert (v4.isNull());        assert (!v4.isArray());        assert (v4.typeCompatible(v));        assert (v5.isNull());        assert (!v5.isArray());        assert (v5.typeCompatible(v));        // Test toMof        Array<char> mofout;        mofout.clear();        MofWriter::appendValueElement(mofout, v);        mofout.append('/0');        // Test toXml        Array<char> out;        XmlWriter::appendValueElement(out, v);        XmlWriter::appendValueElement(out, v);        // Test toString        String valueString = v.toString();#ifdef IO        if (verbose)        {            cout << "MOF = [" << mofout.getData() << "]" << endl;            cout << "toString Output [" << valueString << "]" << endl;        }#endif    // There should be no exceptions to this point in the test.    }    catch(Exception& e)    {        cerr << "Error: " << e.getMessage() << endl;        exit(1);    }    // From here forward, in the future we may have exceptions because    // of the isNull which should generate an exception on the getdata.    // ATTN: KS 12 Feb 2002 This is work in progress until we complete    // adding the exception return to the CIMValue get functions.    try    {        // Test for isNull and the setNullValue function        CIMType type = v.getType();        v.setNullValue(type, false);        assert(v.isNull());        // get the String and XML outputs for v        String valueString2 = v.toString();        Array<char> xmlBuffer;        XmlWriter::appendValueElement(xmlBuffer, v);        xmlBuffer.append('/0');        Array<char> mofOutput2;        MofWriter::appendValueElement(mofOutput2, v);        mofOutput2.append('/0');#ifdef IO        if (verbose)        {            cout << "MOF NULL = [" << mofOutput2.getData() << "]" << endl;            cout << "toString NULL Output [" << valueString2 << "]" << endl;            cout << " XML NULL = [" << xmlBuffer.getData() << "]" << endl;        }#endif        v.clear();        assert(v.isNull());        //v2.clear();        //assert(v2.isNull();    }    catch(Exception& e)    {//.........这里部分代码省略.........

voidPosition::display( ) const{    //! TODO use a graphic engine    int32_t error = std::system( "clear" );    if ( error != 0 )    {        std::cerr << "error when clearing screen!" << error << std::endl;    }    std::vector< std::string > v( m_heigth, std::string( m_width, '.' ) );    v[ m_food.y ][ m_food.x ] = 'o';    if ( m_snake.x >= 0 && m_snake.x < m_width && m_snake.y >= 0 && m_snake.y < m_heigth )    {        char c;        switch ( m_direction )        {        case Direction::RIGHT:            c = '>';            break;        case Direction::LEFT:            c = '<';            break;        case Direction::UP:            c = '^';            break;        case Direction::DOWN:            c = 'v';            break;        default:            c = '?';            break;        }        v[ m_snake.y ][ m_snake.x ] = c;    }    for ( const auto& s : v )    {        std::cout << s << std::endl;    }    std::cout << "score = " << m_score << ", life = " << m_life << ", dir = ";    switch ( m_direction )    {    case Direction::RIGHT:        std::cout << "RIGHT";        break;    case Direction::LEFT:        std::cout << "LEFT";        break;    case Direction::UP:        std::cout << "UP";        break;    case Direction::DOWN:        std::cout << "DOWN";        break;    default:        std::cout << "UNKNOWN";        break;    }    std::cout << std::endl;    std::cout << std::endl;}

bool EntitiesParserListener::parserProperty(TCODParser *parser,const char *name, TCOD_value_type_t type, TCOD_value_t value){	if(currentStructIsBase == false)		return false;	std::string propName = name;	auto entityInfo = info->Entities.back();	if(propName.compare("attributes") == 0 && type == TCOD_TYPE_LIST | TCOD_TYPE_INT)	{		auto list = TCODList<int>(value.list);		for(auto it = list.begin(); it != list.end(); ++it)		{			entityInfo->AttributeValues.push_back(*it);		}	}	else if(propName.compare("vitals") == 0 && type == TCOD_TYPE_LIST | TCOD_TYPE_INT)	{		auto list = TCODList<int>(value.list);		for(auto it = list.begin(); it != list.end(); ++it)		{			entityInfo->VitalValues.push_back(*it);		}	}	else if(propName.compare("skills") == 0 && type == TCOD_TYPE_LIST | TCOD_TYPE_INT)	{		auto list = TCODList<int>(value.list);		for(auto it = list.begin(); it != list.end(); ++it)		{			entityInfo->SkillValues.push_back(*it);		}	}	else 	{		if(type == TCOD_TYPE_INT)		{			auto prop = std::make_shared<Totem::Property<int>>(propName);			prop->set(value.i, false);			entityInfo->IntProperties.push_back(prop);		}		else if(type == TCOD_TYPE_CHAR)		{			auto prop = std::make_shared<Totem::Property<int>>(propName);			prop->set((int)value.c, false);			entityInfo->IntProperties.push_back(prop);		}		else if(type == TCOD_TYPE_FLOAT)		{			auto prop = std::make_shared<Totem::Property<float>>(propName);			prop->set(value.f, false);			entityInfo->FloatProperties.push_back(prop);		}		else if(type == TCOD_TYPE_STRING)		{			auto prop = std::make_shared<Totem::Property<std::string>>(propName);			prop->set(value.s, false);			entityInfo->StringProperties.push_back(prop);		}		else if(type == TCOD_TYPE_COLOR)		{			auto prop = std::make_shared<Totem::Property<TCODColor>>(propName);			prop->set(value.col, false);			entityInfo->ColorProperties.push_back(prop);		}		else if(type == TCOD_TYPE_LIST | TCOD_TYPE_INT)		{			auto list = TCODList<int>(value.list);			if(list.size() == 2)			{				clan::Vec2i v(list.get(0), list.get(1));				auto prop = std::make_shared<Totem::Property<clan::Vec2i>>(propName);				prop->set(v, false);				entityInfo->Vec2iProperties.push_back(prop);			}		}		else			return false;	}	return true;}

boolWindowNamedPropertiesHandler::getOwnPropDescriptor(JSContext* aCx,                                                   JS::Handle<JSObject*> aProxy,                                                   JS::Handle<jsid> aId,                                                   bool /* unused */,                                                   JS::MutableHandle<JSPropertyDescriptor> aDesc)                                                   const{  if (!JSID_IS_STRING(aId)) {    // Nothing to do if we're resolving a non-string property.    return true;  }  bool hasOnPrototype;  if (!HasPropertyOnPrototype(aCx, aProxy, aId, &hasOnPrototype)) {    return false;  }  if (hasOnPrototype) {    return true;  }  nsAutoJSString str;  if (!str.init(aCx, JSID_TO_STRING(aId))) {    return false;  }  // Grab the DOM window.  JS::Rooted<JSObject*> global(aCx, JS_GetGlobalForObject(aCx, aProxy));  nsGlobalWindow* win = xpc::WindowOrNull(global);  if (win->Length() > 0) {    nsCOMPtr<nsIDOMWindow> childWin = win->GetChildWindow(str);    if (childWin && ShouldExposeChildWindow(str, childWin)) {      // We found a subframe of the right name. Shadowing via |var foo| in      // global scope is still allowed, since |var| only looks up |own|      // properties. But unqualified shadowing will fail, per-spec.      JS::Rooted<JS::Value> v(aCx);      if (!WrapObject(aCx, childWin, &v)) {        return false;      }      FillPropertyDescriptor(aDesc, aProxy, 0, v);      return true;    }  }  // The rest of this function is for HTML documents only.  nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(win->GetExtantDoc());  if (!htmlDoc) {    return true;  }  nsHTMLDocument* document = static_cast<nsHTMLDocument*>(htmlDoc.get());  Element* element = document->GetElementById(str);  if (element) {    JS::Rooted<JS::Value> v(aCx);    if (!WrapObject(aCx, element, &v)) {      return false;    }    FillPropertyDescriptor(aDesc, aProxy, 0, v);    return true;  }  nsWrapperCache* cache;  nsISupports* result = document->ResolveName(str, &cache);  if (!result) {    return true;  }  JS::Rooted<JS::Value> v(aCx);  if (!WrapObject(aCx, result, cache, nullptr, &v)) {    return false;  }  FillPropertyDescriptor(aDesc, aProxy, 0, v);  return true;}

int CGVM_PointContents( void ) {	VMSwap v( cgvm );	return cge->PointContents();}