C++ UnitPtr类代码示例

void recall::apply_temp_modifier(unit_map& unit_map)
{
	assert(valid());
	temp_unit_->set_location(recall_hex_);

	DBG_WB << "Inserting future recall " << temp_unit_->name() << " [" << temp_unit_->id()
			<< "] at position " << temp_unit_->get_location() << ".\n";

	//temporarily remove unit from recall list
	UnitPtr it = resources::teams->at(team_index()).recall_list().extract_if_matches_id(temp_unit_->id());
	assert(it);

	//Add cost to money spent on recruits.
	int cost = resources::teams->at(team_index()).recall_cost();
	if (it->recall_cost() > -1) {
		cost = it->recall_cost();
	}

	// Temporarily insert unit into unit_map
	//unit map takes ownership of temp_unit
	unit_map.insert(temp_unit_);

	resources::teams->at(team_index()).get_side_actions()->change_gold_spent_by(cost);
	// Update gold in top bar
	resources::screen->invalidate_game_status();
}

void dlgUnitEditor::on_buttonBox_accepted()
{
    UnitPtr unit = qSharedPointerDynamicCast<Unit>(_entity);
    unit->setName(ui->txtNombre->text());
    unit->setDescripcion(ui->txtDescripcion->text());

    close();
}

dlgUnitEditor::dlgUnitEditor(UnitsModel *model, int selectedEntity, QWidget *parent) :
    QDialog(parent),
    ui(new Ui::dlgUnitEditor)
{
    _model = model;
    ui->setupUi(this);

    _entity = model->getItemByRowid(selectedEntity);
    UnitPtr unit = qSharedPointerDynamicCast<Unit>(_entity);
    ui->txtNombre->setText(unit->name());
    ui->txtDescripcion->setText(unit->description());
}

UnitPtr Restorer::ExtractUnitFromLine(string & str) {
  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  boost::char_separator<char> sep("\t");
  tokenizer tokens(str, sep);

  int size = 0;
  for (tokenizer::iterator tit = tokens.begin(); tit != tokens.end(); ++tit) {
    ++size;
  }

  if (size < 6) {//至少有六段
    MCE_INFO("Restorer::ExtractUnitFromLine. wrong size:" << size << " str:" << str);
    return NULL;
  }

  tokenizer::iterator itr = tokens.begin();
  ++itr;
  Ice::Long id = lexical_cast<Ice::Long> (*itr++);
  set<Ice::Long>::iterator it = outtag_ids_.find(id);
  if (it != outtag_ids_.end()) {
    MCE_INFO("Restorer::ExtractUnitFromLine. matched. id:" << id);
    return NULL;
  }
  //  if (it != outtag_ids_.end()) {
  //    --(it->second);
  //    if (it->second == 0) {
  //      outtag_ids_.erase(it);
  //    }
  //    MCE_INFO("Restorer::ExtractUnitFromLine. matched. id:" << id);
  //    return NULL;
  //  }
  int retry = lexical_cast<int> (*itr++);
  string instance = lexical_cast<string> (*itr++);
  int wrflag = lexical_cast<int> (*itr++);
  string pattern = lexical_cast<string> (*itr++);
  string statement;
  for (; itr != tokens.end(); ++itr) {
    statement += lexical_cast<string> (*itr);
    statement += "\t";
  }

  UnitPtr unit = new Unit(id, retry + 1, instance, wrflag, pattern, statement);
  if (retry > MAX_RETRY) {
    MCE_INFO("Restorer::ExtractUnitFromLine. retry exceed max_retry. " << unit->DumpToString());
    return NULL;
  }
  return unit;
}

bool Section::IsOutOfBoundary(const UnitPtr& unit, OUT Direction& dir)
{
    auto x = unit->GetPos().GetX();
    auto y = unit->GetPos().GetY();
    if (x < m_Boundary.left)
    {
        dir = Direction::LEFT;
        return true;
    }
    if (y < m_Boundary.top)
    {
        dir = Direction::TOP;
        return true;
    }
    if (x > m_Boundary.right)
    {
        dir = Direction::RIGHT;
        return true;
    }
    if (y > m_Boundary.bottom)
    {
        dir = Direction::BOTTOM;
        return true;
    }
    return false;
}

void
FreezeScript::collectCompactIds(const UnitPtr& u, const FreezeScript::CompactIdResolverIPtr& r)
{
    class Visitor : public ParserVisitor
    {
    public:

        Visitor(const FreezeScript::CompactIdResolverIPtr& resolver) : _r(resolver)
        {
        }

        virtual bool visitClassDefStart(const ClassDefPtr& p)
        {
            if(p->compactId() != -1)
            {
                _r->add(p->compactId(), p->scoped());
            }
            return true;
        }

        FreezeScript::CompactIdResolverIPtr _r;
    };

    Visitor v(r);
    u->visit(&v, false);
}

void
PackageVisitor::createModules(const UnitPtr& unit, const string& module, const string& dir)
{
    StringList modules;
    PackageVisitor v(modules);
    unit->visit(&v, false);

    for(StringList::iterator p = modules.begin(); p != modules.end(); ++p)
    {
        vector<string> v;
        if(!IceUtilInternal::splitString(*p, ".", v))
        {
            assert(false);
        }
        string currentModule;
        string path = dir.empty() ? "." : dir;
        for(vector<string>::iterator q = v.begin(); q != v.end(); ++q)
        {
            if(q != v.begin())
            {
                addSubmodule(path, currentModule, *q);
                currentModule += ".";
            }

            currentModule += *q;
            path += "/" + *q;
            createDirectory(path);

            addModule(path, currentModule, module);
        }
    }
}

void
Slice::Ruby::generate(const UnitPtr& un, bool all, bool checksum, const vector<string>& includePaths, Output& out)
{
    out << nl << "require 'Ice'";

    if(!all)
    {
        vector<string> paths = includePaths;
        for(vector<string>::iterator p = paths.begin(); p != paths.end(); ++p)
        {
            *p = fullPath(*p);
        }

        StringList includes = un->includeFiles();
        for(StringList::const_iterator q = includes.begin(); q != includes.end(); ++q)
        {
            string file = changeInclude(*q, paths);
            out << nl << "require '" << file << ".rb'";
        }
    }

    CodeVisitor codeVisitor(out);
    un->visit(&codeVisitor, false);

    if(checksum)
    {
        ChecksumMap checksums = createChecksums(un);
        if(!checksums.empty())
        {
            out << sp;
            for(ChecksumMap::const_iterator p = checksums.begin(); p != checksums.end(); ++p)
            {
                out << nl << "::Ice::SliceChecksums[\"" << p->first << "\"] = \"";
                ostringstream str;
                str.flags(ios_base::hex);
                str.fill('0');
                for(vector<unsigned char>::const_iterator q = p->second.begin(); q != p->second.end(); ++q)
                {
                    str << (int)(*q);
                }
                out << str.str() << "\"";
            }
        }
    }

    out << nl; // Trailing newline.
}

bool
Slice::ObjCGenerator::MetaDataVisitor::visitUnitStart(const UnitPtr& p)
{
    //
    // Validate global metadata in the top-level file and all included files.
    //
    StringList files = p->allFiles();

    for(StringList::iterator q = files.begin(); q != files.end(); ++q)
    {
        string file = *q;
        DefinitionContextPtr dc = p->findDefinitionContext(file);
        assert(dc);
        StringList globalMetaData = dc->getMetaData();
        int headerDir = 0;
        for(StringList::const_iterator r = globalMetaData.begin(); r != globalMetaData.end(); ++r)
        {
            string s = *r;
            if(_history.count(s) == 0)
            {
                if(s.find(_objcPrefix) == 0)
                {
                    static const string objcHeaderDirPrefix = "objc:header-dir:";
                    if(s.find(objcHeaderDirPrefix) == 0 && s.size() > objcHeaderDirPrefix.size())
                    {
                        headerDir++;
                        if(headerDir > 1)
                        {
                            ostringstream ostr;
                            ostr << "ignoring invalid global metadata `" << s
                                 << "': directive can appear only once per file";
                            emitWarning(file, -1, ostr.str());
                            _history.insert(s);
                        }
                        continue;
                    }
                    ostringstream ostr;
                    ostr << "ignoring invalid global metadata `" << s << "'";
                    emitWarning(file, -1, ostr.str());
                }
                _history.insert(s);
            }
        }
    }

    return true;
}

void Section::UnRegisterUnit(const UnitPtr& unit)
{
    unit->SetSection(nullptr);
    m_UnitList.remove_if([&unit](auto& target)
    {
        return target.lock() == unit;
    });
}

Slice::ChecksumMap Slice::createChecksums(const UnitPtr& u)
{
  ChecksumMap result;

  ChecksumVisitor visitor(result);
  u->visit(&visitor, false);

  return result;
}

void SqlQueue::Push(const UnitPtr& unit) {
  {
    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
    q_.push(unit);
    notify();
  }
  MCE_INFO(unit->MakeInLog());
  manager_->Update(1);
  return;
}

void SqlQueue::Execute(const UnitPtr& unit) {
  //  return;//TODO del
  Statement st;
  st << unit->statement_;
  try {
    MCE_INFO(unit->MakeOutLog());
    //    QueryRunner(unit->info_->instance, unit->info_->wrflag,
    //        unit->info_->pattern).store(st);
    usleep(7000);//db平均为7毫秒
    //    sleep(10000);
  } catch (Ice::Exception& e) {
    MCE_WARN("SqlQueue::Execute --> error:" << e);
  } catch (std::exception& e) {
    MCE_WARN("SqlQueue::Execute --> error:" << e.what());
  }
}

bool Section::RegisterUnit(const UnitPtr& unit)
{
    if (unit == nullptr)
        return false;

    Direction dir;
    if (IsOutOfBoundary(unit, dir))
    {
        // 유닛이 바운더리 바깥이면 해당 방향의 섹션에 등록을 시도한다.
        return RegisterUnit(unit, dir);
    }
    // 유닛 리스트에 등록하고, 유닛에게 등록된 섹션을 알려준다.
    // 섹션끼리는 weak_ptr만 들고있기 때문에, 여기서 유닛에게 보관시키는
    // shared_ptr이 유효 카운트이다.
    // 즉, 이 섹션에 포함된 유닛이 0이 될때, 자동으로 이 섹션도 파괴된다.
    m_UnitList.push_back(unit);
    unit->SetSection(shared_from_this());
    return true;
}

//.........这里部分代码省略.........
        {
            cppArgs.push_back("-D" + *i);
        }
    }
    if(opts.isSet("U"))
    {
        vector<string> optargs = opts.argVec("U");
        for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
        {
            cppArgs.push_back("-U" + *i);
        }
    }
    if(opts.isSet("I"))
    {
        includePaths = opts.argVec("I");
        for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
        {
            cppArgs.push_back("-I" + *i);
        }
    }
    debug = opts.isSet("d") || opts.isSet("debug");
    all = opts.isSet("all");
    checksum = opts.isSet("checksum");

    bool ignoreRedefs = false;
    bool keepComments = true;

    for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p)
    {
        string file = *p;
        Slice::PreprocessorPtr icecpp = Slice::Preprocessor::create("icecpp", file, cppArgs);
        FILE* cppHandle = icecpp->preprocess(keepComments, "-D__SLICE2PY__");

        if(cppHandle == 0)
        {
            PyErr_Format(PyExc_RuntimeError, "Slice preprocessing failed for `%s'", cmd);
            return 0;
        }

        UnitPtr u = Slice::Unit::createUnit(ignoreRedefs, all, ice, underscore);
        int parseStatus = u->parse(file, cppHandle, debug);

        if(!icecpp->close() || parseStatus == EXIT_FAILURE)
        {
            PyErr_Format(PyExc_RuntimeError, "Slice parsing failed for `%s'", cmd);
            u->destroy();
            return 0;
        }

        //
        // Generate the Python code into a string stream.
        //
        ostringstream codeStream;
        IceUtilInternal::Output out(codeStream);
        out.setUseTab(false);

        //
        // Emit a Python magic comment to set the file encoding.
        // It must be the first or second line.
        //
        out << "# -*- coding: utf-8 -*-\n";
        generate(u, all, checksum, includePaths, out);
        u->destroy();

        string code = codeStream.str();

        //
        // We need to invoke Ice.updateModules() so that all of the types we've just generated
        // are made "public".
        //
        code += "\nIce.updateModules()\n";

        PyObjectHandle src = Py_CompileString(const_cast<char*>(code.c_str()), const_cast<char*>(file.c_str()),
                                              Py_file_input);
        if(!src.get())
        {
            return 0;
        }

        PyObjectHandle globals = PyDict_New();
        if(!globals.get())
        {
            return 0;
        }
        PyDict_SetItemString(globals.get(), "__builtins__", PyEval_GetBuiltins());

#if PY_VERSION_HEX >= 0x03000000
        PyObjectHandle val = PyEval_EvalCode(src.get(), globals.get(), 0);
#else
        PyObjectHandle val = PyEval_EvalCode(reinterpret_cast<PyCodeObject*>(src.get()), globals.get(), 0);
#endif
        if(!val.get())
        {
            return 0;
        }
    }

    Py_INCREF(Py_None);
    return Py_None;
}