void BcmPort::disable(const std::shared_ptr<Port>& swPort) {
if (!isEnabled()) {
// Already disabled
return;
}
auto pbmp = getPbmp();
for (auto entry : swPort->getVlans()) {
auto rv = opennsl_vlan_port_remove(unit_, entry.first, pbmp);
bcmCheckError(rv, "failed to remove disabled port ",
swPort->getID(), " from VLAN ", entry.first);
}
// Disable packet and byte counter statistic collection.
auto rv = opennsl_port_stat_enable_set(unit_, gport_, false);
bcmCheckError(rv, "Unexpected error disabling counter DMA on port ",
swPort->getID());
// Disable linkscan
rv = opennsl_linkscan_mode_set(unit_, port_, OPENNSL_LINKSCAN_MODE_NONE);
bcmCheckError(rv, "Failed to disable linkscan on port ", swPort->getID());
rv = opennsl_port_enable_set(unit_, port_, false);
bcmCheckError(rv, "failed to disable port ", swPort->getID());
}
int SequenceHandle::compare(std::shared_ptr<SequenceEntry> entry) const
{
if(m_entry->getID() < entry->getID())
return -1;
else if(m_entry->getID() == entry->getID())
return 0;
return 1;
}
void BcmIntfTable::deleteIntf(const std::shared_ptr<Interface>& intf) {
auto iter = intfs_.find(intf->getID());
if (iter == intfs_.end()) {
throw FbossError("Failed to delete a non-existing interface ",
intf->getID());
}
auto bcmIfId = iter->second->getBcmIfId();
intfs_.erase(iter);
bcmIntfs_.erase(bcmIfId);
}
std::shared_ptr<Frame> HistoricMotionProcessor::computeFrame(std::shared_ptr<Frame> current_frame) {
cv::Mat current_mat = current_frame->getData();
cv::Mat blank_mat = cv::Mat(current_mat.size(), current_mat.type());
cv::Mat motion_mask = boost::any_cast<cv::Mat>(current_frame->getFeature("motion_mask"));
cv::Mat motion_locations = boost::any_cast<cv::Mat>(current_frame->getFeature("motion_locs"));
cv::Mat color_mm = cv::Mat(current_mat.size(), current_mat.type());
cv::Vec3i avg_color;
for (int i = 0; i < motion_locations.rows; i++) {
cv::Point loc_i = motion_locations.at<cv::Point>(i);
cv::Vec3b loc_color = current_mat.at<cv::Vec3b>(loc_i);
color_mm.at<cv::Vec3b>(loc_i) = loc_color;
for (int j = 0; j < 3; j++)
avg_color[j] += (int) loc_color[j];
}
if (motion_locations.rows > 0) {
for (int j = 0; j < 3; j++) {
avg_color[j] /= motion_locations.rows;
}
}
current_frame->addFeature("average color", avg_color);
current_frame->addFeature("color motion_mask", color_mm);
return std::make_shared<Frame>(motion_mask, current_frame->getCameraID(), current_frame->getID());
return current_frame;
}
bool Node::add(std::shared_ptr<Node> node){
if(!node) return false;
if(mChildNodesID[node->getID()] == node ||
mChildNodesString[node->getName()] == node)
{
return false;
}
mMutex.lock();
mChildNodesID[node->getID()] = node;
mChildNodesString[node->getName()] = node;
node->mMutex.lock();
node->mParentNode = this;
node->mMutex.unlock();
mMutex.unlock();
return true;
}
bool updateMap(NodeMap* map, std::shared_ptr<Node> origNode,
std::shared_ptr<Node> newNode) {
if (newNode) {
auto ret = map->insert(std::make_pair(newNode->getID(), newNode));
if (!ret.second) {
throw FbossError("duplicate entry ", newNode->getID());
}
return true;
} else {
auto ret = map->insert(std::make_pair(origNode->getID(), origNode));
if (!ret.second) {
throw FbossError("duplicate entry ", origNode->getID());
}
return false;
}
}
void BcmPort::enable(const std::shared_ptr<Port>& swPort) {
if (isEnabled()) {
// Port is already enabled, don't need to do anything
return;
}
auto pbmp = getPbmp();
opennsl_pbmp_t emptyPortList;
OPENNSL_PBMP_CLEAR(emptyPortList);
int rv;
for (auto entry : swPort->getVlans()) {
if (!entry.second.tagged) {
rv = opennsl_vlan_port_add(unit_, entry.first, pbmp, pbmp);
} else {
rv = opennsl_vlan_port_add(unit_, entry.first, pbmp, emptyPortList);
}
bcmCheckError(rv, "failed to add enabled port ",
swPort->getID(), " to VLAN ", entry.first);
}
// Drop packets to/from this port that are tagged with a VLAN that this
// port isn't a member of.
rv = opennsl_port_vlan_member_set(unit_, port_,
OPENNSL_PORT_VLAN_MEMBER_INGRESS |
OPENNSL_PORT_VLAN_MEMBER_EGRESS);
bcmCheckError(rv, "failed to set VLAN filtering on port ",
swPort->getID());
// Set the speed and ingress vlan before enabling
program(swPort);
// Enable packet and byte counter statistic collection.
rv = opennsl_port_stat_enable_set(unit_, gport_, true);
if (rv != OPENNSL_E_EXISTS) {
// Don't throw an error if counter collection is already enabled
bcmCheckError(rv, "Unexpected error enabling counter DMA on port ",
swPort->getID());
}
// Enable linkscan
rv = opennsl_linkscan_mode_set(unit_, port_, OPENNSL_LINKSCAN_MODE_SW);
bcmCheckError(rv, "Failed to enable linkscan on port ", swPort->getID());
rv = opennsl_port_enable_set(unit_, port_, true);
bcmCheckError(rv, "failed to enable port ", swPort->getID());
}
void LinkAggregationManager::aggregatePortChanged(
const std::shared_ptr<AggregatePort>& oldAggPort,
const std::shared_ptr<AggregatePort>& newAggPort) {
CHECK_EQ(oldAggPort->getID(), newAggPort->getID());
auto oldSubportRange = oldAggPort->sortedSubports();
if (oldAggPort->getName() == newAggPort->getName() &&
oldAggPort->getDescription() == newAggPort->getDescription() &&
oldAggPort->getSystemPriority() == newAggPort->getSystemPriority() &&
oldAggPort->getSystemID() == newAggPort->getSystemID() &&
std::equal(
oldSubportRange.begin(),
oldSubportRange.end(),
newAggPort->sortedSubports().begin())) {
return;
}
aggregatePortAdded(newAggPort);
}
void Board::addTeleporter(std::shared_ptr<Teleporter> teleporter)
{
assert(teleporter != nullptr);
if (m_teleporters.find(teleporter->getExternalID()) != m_teleporters.end()) {
m_teleporters.find(teleporter->getExternalID())->second = teleporter;
}
else {
m_teleporters.insert(std::make_pair(teleporter->getID(), nullptr));
m_teleporters.insert(std::make_pair(teleporter->getExternalID(), teleporter));
}
}
void MiscDevice::addPeer(std::shared_ptr<MiscPeer> peer)
{
try
{
_peersMutex.lock();
if(_peersByID.find(peer->getID()) == _peersByID.end()) _peersByID[peer->getID()] = peer;
}
catch(const std::exception& ex)
{
GD::out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
GD::out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
GD::out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
_peersMutex.unlock();
}
void MAMResultConvertor::doConvertToLua(lua_State* L, std::shared_ptr<MAMResult> payload) {
lua_createtable(L, 0, 0);
if (convertors->convertToLuaUntyped(L, payload->getPayload()) > 0) {
lua_setfield(L, -2, "payload");
}
lua_pushstring(L, payload->getID().c_str());
lua_setfield(L, -2, "id");
if (payload->getQueryID()) {
lua_pushstring(L, (*payload->getQueryID()).c_str());
lua_setfield(L, -2, "query_id");
}
}
void MaterialManager::initializeMaterial( const std::shared_ptr<Geometry3D>& geometry )
{
if (!geometry) return;
auto meshes = geometry->getMeshes();
int id = geometry->getID();
if (m_materials.find(id) != m_materials.end()) return;
std::vector<MaterialData> dat;
dat.reserve(meshes.size());
std::string dir = utils::Utils::getPath(geometry->getFilename());
for (size_t i = 0; i < meshes.size(); i++)
{
MaterialData mat;
if (!meshes[i].material.diffuseMapFilename.empty())
{
std::string texName = findTextureName(dir, meshes[i].material.diffuseMapFilename);
std::string path = dir + texName;
if (utils::Utils::exists(path))
{
mat.textures[MAT_DIFFUSE_MAP] = createTexture(path);
}
}
if (!meshes[i].material.normalMapFilename.empty())
{
std::string texName = findTextureName(dir, meshes[i].material.normalMapFilename);
std::string path = dir + texName;
if (utils::Utils::exists(path))
{
mat.textures[MAT_NORMAL_MAP] = createTexture(path);
}
}
if (!meshes[i].material.specularMapFilename.empty())
{
std::string texName = findTextureName(dir, meshes[i].material.specularMapFilename);
std::string path = dir + texName;
if (utils::Utils::exists(path))
{
mat.textures[MAT_SPECULAR_MAP] = createTexture(path);
}
}
dat.push_back(mat);
}
m_materials.insert(std::make_pair(id, dat));
}
std::shared_ptr<Texture> MaterialManager::getTexture( const std::shared_ptr<Geometry3D>& geometry, int meshIndex, MaterialTexture textureType )
{
int id = geometry->getID();
auto it = m_materials.find(id);
if (it != m_materials.end())
{
if (meshIndex >= 0 && meshIndex < (int)it->second.size())
{
auto texPtr = it->second[meshIndex].textures[textureType];
if (!texPtr.expired()) return texPtr.lock();
}
}
return std::shared_ptr<Texture>();
}
void SessionManager::removeSession(std::shared_ptr<Session> session)
{
// 다른 유저에게 로그아웃을 알린다.
int id = session->getID();
for(auto& se : _sessions)
{
if ( id == se.second->getID() )
continue;
flatbuffers::FlatBufferBuilder builder;
auto obj = fpacket::CreatePacketRemovePlayer(builder, id);
builder.Finish(obj);
Packet* packet = new Packet();
packet->encode(builder.GetBufferPointer(), builder.GetSize(), PacketType::REMOVE_PLAYER);
se.second->write(packet);
}
// 내 세션을 지운다.
eraseSession(id);
session.reset();
}
void LinkAggregationManager::aggregatePortAdded(
const std::shared_ptr<AggregatePort>& aggPort) {
PortIDToController::iterator it;
for (const auto& subport : aggPort->sortedSubports()) {
it = portToController_.find(subport.portID);
CHECK_NE(it, portToController_.end());
it->second->stopMachines();
it->second.reset(new LacpController(
subport.portID,
sw_->getLacpEvb(),
subport.priority,
subport.rate,
subport.activity,
aggPort->getID(),
aggPort->getSystemPriority(),
aggPort->getSystemID(),
aggPort->getMinimumLinkCount(),
this));
it->second->startMachines();
}
}
void MaterialManager::initializeMaterial(const std::shared_ptr<Geometry3D>& geometry,
const std::string& diffuseMap,
const std::string& normalMap,
const std::string& specularMap)
{
if (!geometry) return;
auto meshes = geometry->getMeshes();
int id = geometry->getID();
if (m_materials.find(id) != m_materials.end()) return;
std::vector<MaterialData> dat;
dat.reserve(meshes.size());
for (size_t i = 0; i < meshes.size(); i++)
{
MaterialData mat;
if (!diffuseMap.empty())
{
mat.textures[MAT_DIFFUSE_MAP] = createTexture(diffuseMap);
}
if (!normalMap.empty())
{
mat.textures[MAT_NORMAL_MAP] = createTexture(normalMap);
}
if (!specularMap.empty())
{
mat.textures[MAT_SPECULAR_MAP] = createTexture(specularMap);
}
dat.push_back(mat);
}
m_materials.insert(std::make_pair(id, dat));
}
void LinkAggregationManager::portChanged(
const std::shared_ptr<Port>& oldPort,
const std::shared_ptr<Port>& newPort) {
auto portId = newPort->getID();
if (oldPort->getOperState() == Port::OperState::DOWN &&
newPort->getOperState() == Port::OperState::UP) {
auto it = portToController_.find(portId);
if (it == portToController_.end()) {
LOG(ERROR) << "Port " << portId << " not found";
return;
}
it->second->portUp();
} else if (
oldPort->getOperState() == Port::OperState::UP &&
newPort->getOperState() == Port::OperState::DOWN) {
auto it = portToController_.find(portId);
if (it == portToController_.end()) {
LOG(ERROR) << "Port " << portId << " not found";
return;
}
it->second->portDown();
}
}
void Interfacer::addLuaAgentPtr(std::shared_ptr<AgentLuaInterface> luaPtr)
{
std::lock_guard<std::mutex> guard(agentPtrMutex);
agents.insert(make_pair(luaPtr->getID(), luaPtr));
}
bool EntityManager::addEntity(std::shared_ptr<Entity> E) {
Entities[E->getID()] = E;
return true;
}
void Entity::addSystem(std::shared_ptr<System> S) {
Systems[S->getID()] = S;
S->onAttach(*this);
changed = true;
}
void onFoundResource(std::shared_ptr<SimulatorRemoteResource> resource)
{
JNIEnv *env = getEnv();
if (nullptr == env)
return;
jobject foundResourceListener = env->NewLocalRef(m_listener);
if (!foundResourceListener)
{
releaseEnv();
return;
}
jclass foundResourceCls = env->GetObjectClass(foundResourceListener);
if (!foundResourceCls)
{
releaseEnv();
return;
}
jmethodID foundResourceMId = env->GetMethodID(foundResourceCls, "onResourceCallback",
"(Lorg/oic/simulator/clientcontroller/SimulatorRemoteResource;)V");
if (!foundResourceMId)
{
releaseEnv();
return;
}
JniSimulatorRemoteResource *jniSimulatorResource = new JniSimulatorRemoteResource(resource);
if (!jniSimulatorResource)
{
releaseEnv();
return;
}
jobject simulatorResource = SimulatorRemoteResourceToJava(env,
reinterpret_cast<jlong>(jniSimulatorResource));
jfieldID fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mUri",
"Ljava/lang/String;");
jstring jUri = env->NewStringUTF(resource->getURI().c_str());
env->SetObjectField(simulatorResource, fieldID, jUri);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mConnType", "I");
jint jConnType = resource->getConnectivityType();
env->SetIntField(simulatorResource, fieldID, jConnType);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mHost",
"Ljava/lang/String;");
jstring jHost = env->NewStringUTF(resource->getHost().c_str());
env->SetObjectField(simulatorResource, fieldID, jHost);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mId",
"Ljava/lang/String;");
jstring jUid = env->NewStringUTF(resource->getID().c_str());
env->SetObjectField(simulatorResource, fieldID, jUid);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResTypes",
"Ljava/util/LinkedList;");
std::vector<std::string> resourceTypes = resource->getResourceTypes();
jobject jResTypes = convertStringVectorToJavaList(env, resourceTypes);
env->SetObjectField(simulatorResource, fieldID, jResTypes);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mResInterfaces",
"Ljava/util/LinkedList;");
std::vector<std::string> interfaceTypes = resource->getResourceInterfaces();
jobject jResInterfaces = convertStringVectorToJavaList(env, interfaceTypes);
env->SetObjectField(simulatorResource, fieldID, jResInterfaces);
fieldID = env->GetFieldID(gSimulatorClassRefs.classSimulatorRemoteResource, "mIsObservable", "Z");
env->SetBooleanField(simulatorResource, fieldID, resource->isObservable());
env->CallVoidMethod(foundResourceListener, foundResourceMId, simulatorResource);
if ((env)->ExceptionCheck())
{
delete jniSimulatorResource;
releaseEnv();
return;
}
releaseEnv();
}
std::shared_ptr<Teleporter> Board::getOtherTeleporter(std::shared_ptr<Teleporter> teleporter) const {
if (m_teleporters.find(teleporter->getID()) == m_teleporters.end()) {
return nullptr;
}
return m_teleporters.find(teleporter->getID())->second;
}
void EntityManager::registerSystem(std::shared_ptr<System> S) {
S->generateID();
SystemMappings[S->getName()] = S->getID();
SystemFactories[S->getID()] = S->createFactory();
Systems[S->getID()] = S;
}
void SceneGraph::removeNode(std::shared_ptr< const spvs::SceneNode > node)
{
removeNode(node->getID());
}
