Scalar calculateGradientFirst(Geometry1& point, Geometry2& line, Derivative1& dpoint) {
        if(dist.norm() == 0)
            return 1.;

        const Vector3 d_dist = -dpoint.point() + dpoint.point().dot(line.direction())*line.direction();
        const Scalar res = dist.dot(d_dist)/dist.norm();
#ifdef DCM_USE_LOGGING
        if(!boost::math::isfinite(res))
            BOOST_LOG_SEV(log, details::error) << "Unnormal first cluster gradient detected: "<<res
                           <<" with point: "<<point.point().transpose()<<", line: "<<line.point().transpose()
                           << line.direction().transpose() <<" and dpoint: "<<dpoint.point().transpose();
#endif
        return res;
    };

bool generalization_indexer::is_leaf(const object& o) const {
    // FIXME: massive hack. must not add leafs for services.
    const auto uds(object_types::user_defined_service);
    const bool is_service(o.object_type() == uds);
    if (o.is_parent() || !o.is_child() || is_service) {
        BOOST_LOG_SEV(lg, debug)
            << "Type is not in a generalization relationship."
            << " is parent: " << o.is_parent()
            << " is child: " << o.is_child()
            << " is service: " << is_service;
        return false;
    }
    return true;
}

int main(int, char*[])
{
#if defined(BOOST_LOG_USE_NATIVE_SYSLOG)
    init_native_syslog();
#elif !defined(BOOST_LOG_NO_ASIO)
    init_builtin_syslog();
#endif

    BOOST_LOG_SCOPED_THREAD_TAG("MyLevel", std::string, "warning");
    src::severity_logger< > lg;
    BOOST_LOG_SEV(lg, 3) << "Hello world!";

    return 0;
}

std::list<field_definition>
instantiator::instantiate(const field_definition& fd) const {
    validate(fd);

    BOOST_LOG_SEV(lg, debug) << "Instantiating template: " << fd;

    std::list<field_definition> r;
    const auto dt(fd.definition_type());
    if (dt == field_definition_types::global_template)
        r = instantiate_global_template(fd);
    else if (dt == field_definition_types::facet_template)
        r = instantiate_facet_template(fd);
    else if (dt == field_definition_types::formatter_template)
        r = instantiate_formatter_template(fd);
    else {
        BOOST_LOG_SEV(lg, error) << unsupported_definition_type << dt;
        BOOST_THROW_EXCEPTION(instantiation_error(unsupported_definition_type +
                boost::lexical_cast<std::string>(dt)));
    }

    BOOST_LOG_SEV(lg, debug) << "Instantiation result: " << r;
    return r;
}

helper_configuration helper_expander::
make_configuration(const feature_group& fg, const model& fm) const {
    BOOST_LOG_SEV(lg, debug) << "Started making the configuration.";
    helper_configuration r;
    r.streaming_properties(fm.streaming_properties());

    for (auto& pair : fm.formattables()) {
        const auto id(pair.first);
        BOOST_LOG_SEV(lg, debug) << "Procesing element: " << id;

        auto& formattable(pair.second);
        auto& segment(*formattable.master_segment());
        const auto& cfg(*segment.configuration());
        const variability::helpers::configuration_selector s(cfg);
        const auto fam(s.get_text_content_or_default(fg.family));
        r.helper_families()[id] = fam;
    }

    BOOST_LOG_SEV(lg, debug) << "Finished making the configuration. Result:"
                             << r;

    return r;
}

    Master::Master(const std::shared_ptr<Library>& library, const MasterParameters& parameters):
	_library(library),
	_parameters(parameters),
	nodeAcceptor(library->ioService(), parseTcpEndpoint(parameters.nodeEndpoint)),
	clientAcceptor(library->ioService(), parseTcpEndpoint(parameters.clientEndpoint)),
	heartbeatTimer(library->ioService()),
	heartbeatRunning(true),
	_sslContext(ssl::context::tlsv1),
	disposed(false),
	nodeAcceptorRunning(true),
	clientAcceptorRunning(true)
	{
		// Setup SSL
		std::string pw = parameters.sslPassword;
		sslContext().set_password_callback([pw](std::size_t, ssl::context::password_purpose) { return pw; });
		
		try {
			BOOST_LOG_SEV(log, LogLevel::Info) <<
			format("Using %s as the certificate chain file.") % parameters.sslCertificateFile;
			
			sslContext().use_certificate_chain_file(parameters.sslCertificateFile);
		} catch (const std::exception& ex) {
			MSCThrow(InvalidDataException
			(str(format("Error occured while attempting to use '%s' as the "
						"certificate chain file: %s") %
				 parameters.sslCertificateFile % ex.what())));
		}
		try {
			BOOST_LOG_SEV(log, LogLevel::Info) <<
			format("Using %s as the private key file.") % parameters.sslPrivateKeyFile;
			
			sslContext().use_private_key_file(parameters.sslPrivateKeyFile, boost::asio::ssl::context::pem);
		} catch (const std::exception& ex) {
			MSCThrow(InvalidDataException
			(str(format("Error occured while attempting to use '%s' as the "
						"private key file: %s") %
				 parameters.sslPrivateKeyFile % ex.what())));
		}
		
		BOOST_LOG_SEV(log, LogLevel::Debug) << "SSL is ready.";
		
		// Prepare to accept the first client and node
		BOOST_LOG_SEV(log, LogLevel::Debug) << "Preparing to accept clients and nodes.";
		waitingNodeConnection = std::make_shared<MasterNodeConnection>(*this);
		waitingClient = std::make_shared<MasterClient>(*this, 1,
													   _parameters.allowVersionSpecification);
		
        acceptNodeConnectionAsync(true);
        acceptClientAsync(true);

		// Start heartbeat
		BOOST_LOG_SEV(log, LogLevel::Debug) << "Starting heartbeat.";
        doHeartbeat(boost::system::error_code());
		
		BOOST_LOG_SEV(log, LogLevel::Info) <<
		format("Merlion Master Server Core (%s) running.") % MSC_VERSION_STRING;
    }

void voice_card_control::cti_callout(boost::shared_ptr<cti_call_out_param> cti_call_out_param_)
{
	std::size_t chID;
	try
	{
		chID = m_channel_queue.take();
	}
	catch (std::out_of_range)
	{
		BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "业务流水:" << cti_call_out_param_->m_transId << " 获取通道失败, 通道全部繁忙";
		//继续下一次呼叫
		cti_callout_again(cti_call_out_param_);
		return;
	}
	BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "业务流水:" << cti_call_out_param_->m_transId << " 获取到得通道状态为:" << SsmChkAutoDial(chID) << ", 通道号码:" << chID;
	SsmSetTxCallerId(chID, cti_call_out_param_->m_authCode.c_str());
	if (SsmAutoDial(chID, cti_call_out_param_->m_pn.c_str()) == 0){
		BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "业务流水:" << cti_call_out_param_->m_transId << " 已发送请求, 已将此通道对应状态清空, 通道号码:" << chID;
		boost::shared_ptr<trunk> t = m_trunk_vector.at(chID);
		boost::unique_lock<boost::mutex> unique_lock_(t->m_trunk_mutex, boost::defer_lock);
		if (unique_lock_.try_lock())
		{
			t->m_client_socket = cti_call_out_param_->m_base_client;
			t->m_transId = cti_call_out_param_->m_transId;
			t->m_caller_id = cti_call_out_param_->m_authCode;
			t->m_called_id = cti_call_out_param_->m_pn;
			t->m_hungup_by_echo_tone = cti_call_out_param_->m_hungup_by_echo_tone;
			t->m_step = TRK_CALLOUT_DAIL;
			t->m_callTime.restart();
		}
		else
		{
			BOOST_LOG_SEV(cia_g_logger, Critical) << "业务流水:" << cti_call_out_param_->m_transId << ", 严重异常， 被分配的语音通道处于占用状态， 请程序猿通宵解决问题";
		}
	}
	else {
		m_channel_queue.put(chID);
		//上一次呼叫失败，继续呼叫
		if (cti_call_out_param_->m_repeat_call_out)
		{
			cti_call_out_param_->m_repeat_call_out = false;
			BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "业务流水:" << cti_call_out_param_->m_transId << "上一次呼叫失败，继续呼叫";
			cti_callout_again(cti_call_out_param_);
		}
		//已经连续两次呼叫失败， 直接返回失败
		else
		{
			BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "业务流水:" << cti_call_out_param_->m_transId << "已经连续两次呼叫失败， 直接返回失败";
			ciaMessage msg;
			msg.set_type(CIA_CALL_RESPONSE);
			msg.set_transid(cti_call_out_param_->m_transId);
			msg.set_status(CIA_CALL_FAIL);
			cti_call_out_param_->m_base_client->do_write(chat_message(msg));
			return;
		}
	}
}

std::unordered_map<std::string, std::list<std::string> >
generate(const inclusion_dependencies_builder_factory& f,
    std::forward_list<
        boost::shared_ptr<
            inclusion_dependencies_provider_interface<SmlEntity>
            >
        > providers, const SmlEntity& e) {

    const auto n(sml::string_converter::convert(e.name()));
    BOOST_LOG_SEV(lg, debug) << "Creating inclusion dependencies for: " << n;

    std::unordered_map<std::string, std::list<std::string> > r;
    for (const auto p : providers) {
        BOOST_LOG_SEV(lg, debug) << "Providing for: " << p->formatter_name();
        auto id(p->provide(f, e));

        if (!id)
            continue;

        id->sort(include_directive_comparer);
        id->unique();
        const auto id_pair(std::make_pair(p->formatter_name(), *id));
        const bool inserted(r.insert(id_pair).second);
        if (!inserted) {
            BOOST_LOG_SEV(lg, error) << duplicate_formatter_name
                                     << p->formatter_name()
                                     << " for type: " << n;
            BOOST_THROW_EXCEPTION(building_error(duplicate_formatter_name +
                    p->formatter_name()));
        }
    }

    BOOST_LOG_SEV(lg, debug) << "Finished creating inclusion dependencies for: "
                             << n;

    return r;
}

void workflow::initialise_context_activity(const std::string& model_name,
    const std::string& external_modules, bool is_target) {

    context_ = context();
    auto& m(context_.model());
    m.name(create_name_for_model(model_name, external_modules));
    m.original_model_name(model_name);
    BOOST_LOG_SEV(lg, debug) << "Model name: " << m.name().qualified();

    m.origin_type(yarn::origin_types::user);
    m.is_target(is_target);

    const auto mm(create_module_for_model(m.name(), is_target));
    m.modules().insert(std::make_pair(mm.name().qualified(), mm));
}

    Scalar calculateGradientSecond(const E::MatrixBase<DerivedA>& point,
                                   const E::MatrixBase<DerivedB>& segment,
                                   const E::MatrixBase<DerivedC>& dsegment) {

        const Vector3 d_cross = - (dsegment.template head<3>().cross(v02) + v01.cross(dsegment.template tail<3>()));
        const Vector3 d_v12   = dsegment.template head<3>() - dsegment.template tail<3>();
        const Scalar res = cross.dot(d_cross)/(cross_n*v12_n) - v12.dot(d_v12)*cross_v12_n;
#ifdef DCM_USE_LOGGING
        if(!boost::math::isfinite(res))
            BOOST_LOG_SEV(log, error) << "Unnormal second cluster gradient detected: "<<res
                           <<" with point: "<<point.transpose()<<", segment: "<<segment.transpose()
                           << "and dsegment: "<<dsegment.transpose();
#endif
        return res;
    };

bool HibernationEnabled()
{
    #pragma warning (push, 4)
    #pragma warning( disable : 4800 )
    BOOST_LOG_SEV(logger(), debug) << "IsPwrHibernateAllowed(): " << (bool)IsPwrHibernateAllowed();
    BOOST_LOG_SEV(logger(), debug) << "IsPwrShutdownAllowed(): " << (bool)IsPwrShutdownAllowed();
    BOOST_LOG_SEV(logger(), debug) << "IsPwrSuspendAllowed(): " << (bool)IsPwrSuspendAllowed();
    #pragma warning (pop)

    SYSTEM_POWER_CAPABILITIES systemPowerCapabilities = {0};
    if (!GetPwrCapabilities(&systemPowerCapabilities)) {
        DWORD last_error = GetLastError();
        std::string msg = Utilities::MakeString() << "GetPwrCapabilities() failed. Reason: " << last_error;
        BOOST_LOG_SEV(logger(), error) << msg;
        return false;
    }

    #pragma warning (push, 4)
    #pragma warning( disable : 4800 )
    BOOST_LOG_SEV(logger(), debug) << "systemPowerCapabilities.Hiberboot: " << (bool)systemPowerCapabilities.Hiberboot;
    #pragma warning (pop)

    return !!systemPowerCapabilities.Hiberboot;
}

void Module3D<Typelist, ID>::type<Sys>::Geometry3D_base<Derived>::set(const T& geometry) {

    m_geometry = geometry;
    //first init, so that the geometry internal vector has the right size
    Base::template init< typename geometry_traits<T>::tag >();
    //now write the value;
    (typename geometry_traits<T>::modell()).template extract<Scalar,
    typename geometry_traits<T>::accessor >(geometry, Base::getValue());

#ifdef DCM_USE_LOGGING
    BOOST_LOG_SEV(Base::log, information) << "Set global Value: " << Base::getValue().transpose();
#endif
    
    reset();
};

void merger::add_target(const model& target) {
    const auto qn(target.name().qualified());
    require_not_has_target(qn);

    has_target_ = true;
    merged_model_.name(target.name());
    merged_model_.documentation(target.documentation());
    merged_model_.leaves(target.leaves());
    merged_model_.modules(target.modules());
    merged_model_.references(target.references());
    merged_model_.extensions(target.extensions());
    merged_model_.is_target(true);

    BOOST_LOG_SEV(lg, debug) << "added target model: " << qn;
}

void voice_card_control::init_cti()
{
	BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "读取语音卡配置文件";
	if (SsmStartCti("ShConfig.ini", "ShIndex.ini") != 0)
	{
		show_error();
		BOOST_LOG_SEV(cia_g_logger, Critical) << "读取语音卡配置文件失败";
		throw std::runtime_error("读取语音卡配置文件失败");
	}
	else{
		BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "语音卡配置文件读取成功";
	}
	//设置驱动程序抛出事件的模式

	EVENT_SET_INFO EventMode;
	EventMode.dwWorkMode = EVENT_CALLBACK;                               // 事件回调模式
	EventMode.lpHandlerParam = (LPVOID)voice_card_control::cti_callback; // 注册回调函数

	SsmSetEvent(0xffff, -1, true, &EventMode);	                         // 启动事件触发模式

	//如果要在程序中获取SS7消息, 则需要同时注意以下两点
	//配置文件 ShConfig.ini 中, GetMsuOnAutoHandle = 1
	//程序中: SsmSetEvent(E_RCV_Ss7Msu, -1, true, &EventMode);
	SsmSetEvent(E_RCV_Ss7Msu, -1, true, &EventMode);

	BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "正在初始化语音卡通道, 预期耗时15秒";
	//	为了兼容1号信令，注释以下代码，改为sleep 15秒
	//while (SsmSearchIdleCallOutCh(160, 0x1E0000) < 0){	                 // 循环等待, 直到能够获取语音卡空闲通道号, 语音卡初始化完毕
	//	boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
	//}
	boost::this_thread::sleep_for(boost::chrono::seconds(15));
	BOOST_LOG_SEV(cia_g_logger, RuntimeInfo) << "语音卡通道初始化完毕";
	for (std::size_t i = 0; i < m_numChannelCount; i++){
		m_channel_queue.put(i);
	}
}

    bool CameraGigeAravis::setSize(int width, int height, bool customSize) {

        if(customSize) {

            arv_camera_set_region(camera, 0, 0,width,height);
            arv_camera_get_region (camera, NULL, NULL, &mWidth, &mHeight);
            BOOST_LOG_SEV(logger, notification) << "Camera region size : " << mWidth << "x" << mHeight;

        // Default is maximum size
        }else {

            int sensor_width, sensor_height;

            arv_camera_get_sensor_size(camera, &sensor_width, &sensor_height);
            BOOST_LOG_SEV(logger, notification) << "Camera sensor size : " << sensor_width << "x" << sensor_height;

            arv_camera_set_region(camera, 0, 0,sensor_width,sensor_height);
            arv_camera_get_region (camera, NULL, NULL, &mWidth, &mHeight);

        }

        return true;

    }

void injector::inject_visitors(intermediate_model& m) {
    BOOST_LOG_SEV(lg, debug) << "Injecting visitors.";

    std::list<visitor> visitors;
    for (auto& pair : m.objects()) {
        auto& o(pair.second);

        if (!o.is_visitable())
            continue;

        if (o.leaves().empty()) {
            const auto qn(o.name().qualified());
            BOOST_LOG_SEV(lg, error) << zero_leaves << qn;
            BOOST_THROW_EXCEPTION(injection_error(zero_leaves + qn));
        }

        const auto v(create_visitor(o, o.leaves()));
        inject_visitable_by(o, o.leaves(), v.name(), m);
        visitors.push_back(v);
    }

    for (const auto v : visitors) {
        BOOST_LOG_SEV(lg, debug) << "Adding visitor: "
                                 << v.name().qualified();

        const auto pair(std::make_pair(v.name().qualified(), v));
        const auto i(m.visitors().insert(pair));
        if (!i.second) {
            const auto qn(v.name().qualified());
            BOOST_LOG_SEV(lg, error) << duplicate_name << qn;
            BOOST_THROW_EXCEPTION(injection_error(duplicate_name + qn));
        }
    }

    BOOST_LOG_SEV(lg, debug) << "Done injecting visitors.";
}

layer hydrator::read_layer() {
    validate_current_element(dia_layer);

    layer layer;
    layer.name(read_xml_string_attribute(dia_name));
    layer.visible(try_read_xml_bool_attribute(dia_layer_visible));
    layer.active(try_read_xml_bool_attribute(dia_layer_active));
    BOOST_LOG_SEV(lg, debug) << "Reading layer: " << layer.name();

    std::vector<object> objects;
    const bool is_self_closing(reader_.is_empty());

    reader_.read();
    if (!is_self_closing) {
        do {
            objects.push_back(read_object());
        } while (!is_end_element(dia_layer));
        reader_.read();
    }

    layer.objects(objects);
    BOOST_LOG_SEV(lg, debug) << "Read layer: " << layer.name();
    return layer;
}

    Scalar calculateGradientFirst(const E::MatrixBase<DerivedA>& point,
                                  const E::MatrixBase<DerivedB>& segment,
                                  const E::MatrixBase<DerivedC>& dpoint) {

        const Vector3 d_point = dpoint; //eigen only acceppts vector3 for cross product
        const Vector3 d_cross = d_point.cross(v02) + v01.cross(d_point);
        const Scalar res = cross.dot(d_cross)/(cross_n*v12_n);
#ifdef DCM_USE_LOGGING
        if(!boost::math::isfinite(res))
            BOOST_LOG_SEV(log, error) << "Unnormal first cluster gradient detected: "<<res
                           <<" with point: "<<point.transpose()<<", segment: "<<segment.transpose()
                           <<" and dpoint: "<<dpoint.transpose();
#endif
        return res;
    };

bool Linklet::messageParsed(Message &msg)
{
  if (m_state == State::IntroWait) {
    // We have received the hello message, extract information and detach
    Protocol::Interplex::Hello hello = message_cast<Protocol::Interplex::Hello>(msg);
    Contact peerContact = Contact::fromMessage(hello.local_contact());
    if (peerContact.isNull()) {
      BOOST_LOG_SEV(m_logger, log::error) << "Invalid peer contact in hello message!";
      return false;
    }

    m_peerContact = peerContact;

    // Perform additional verification on the peer before transitioning into
    // the connected state
    if (!signalVerifyPeer(shared_from_this()) || !m_manager.verifyPeer(peerContact)) {
      BOOST_LOG_SEV(m_logger, log::error) << "Peer verificaton has failed!";
      return false;
    }

    BOOST_LOG_SEV(m_logger, log::normal) << "Introductory phase with " << peerContact.nodeId().hex() << " completed.";
    m_state = State::Connected;
    signalConnectionSuccess(shared_from_this());

    // The above signal may close this linklet, in this case we should not start reading,
    // otherwise this will cause a segmentation fault
    if (m_state != State::Connected)
      return false;
  } else {
    // Payload has been read, emit message and detach
    signalMessageReceived(shared_from_this(), msg);
  }

  msg.detach();
  return true;
}

formattables::path_derivatives
inclusion_directives_factory::path_derivatives_for_formatter_name(
    const std::unordered_map<std::string,
    formattables::path_derivatives>& pd,
    const std::string& formatter_name) const {

    const auto i(pd.find(formatter_name));
    if (i == pd.end()) {
        BOOST_LOG_SEV(lg, error) << formatter_name_not_found
                                 << formatter_name;
        BOOST_THROW_EXCEPTION(
            building_error(formatter_name_not_found + formatter_name));
    }
    return i->second;
}