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

/** * Set async I/O polling method. This function can also be called while the * program is running. * * @param method New polling method * * @return 0 if success, otherwise errorcode */int poll_method_set(enum poll_method method){	struct re *re;	int err;	switch (method) {#ifdef HAVE_POLL	case METHOD_POLL:		break;#endif#ifdef HAVE_SELECT	case METHOD_SELECT:		break;#endif#ifdef HAVE_EPOLL	case METHOD_EPOLL:		if (!epoll_check())			return EINVAL;		break;#endif#ifdef HAVE_ACTSCHED	case METHOD_ACTSCHED:		break;#endif	default:		DEBUG_WARNING("poll method not supported: '%s'/n",			      poll_method_name(method));		return EINVAL;	}	re = re_get();	re->method = method;	re->update = true;	DEBUG_INFO("Setting async I/O polling method to `%s'/n",		   poll_method_name(re->method));	err = fd_setsize(DEFAULT_MAXFDS);	if (err)		return err;	err = poll_init(re);	if (err)		return err;	return rebuild_fds(re);}

int audio_encoder_set(struct audio *a, const struct aucodec *ac,			  int pt_tx, const char *params, struct user_extra_data_t *user_data){	struct autx *tx;	int err = 0;	bool reset;	if (!a || !ac)		return EINVAL;	tx = &a->tx;	reset = !aucodec_equal(ac, tx->ac);	if (ac != tx->ac) {		re_printf("Set audio encoder: %s %uHz %dch/n", ac->name, get_srate(ac), ac->ch);		/* Audio source must be stopped first */		if (reset) {			tx->ausrc = mem_deref(tx->ausrc);		}		tx->is_g722 = (0 == str_casecmp(ac->name, "G722"));		tx->enc = mem_deref(tx->enc);		tx->ac = ac;	}	if (ac->encupdh) {		struct auenc_param prm;		prm.ptime = tx->ptime;		err = ac->encupdh(&tx->enc, ac, &prm, params);		if (err) {			DEBUG_WARNING("alloc encoder: %m/n", err);			return err;		}	}	stream_set_srate(a->strm, get_srate(ac), get_srate(ac));	stream_update_encoder(a->strm, pt_tx);	if (!tx->ausrc) {		err |= audio_start(a, user_data);	}	return err;}

void stream_send_fir(struct stream *s, bool pli){	int err;	if (!s)		return;	if (pli)		err = rtcp_send_pli(s->rtp, s->ssrc_rx);	else		err = rtcp_send_fir(s->rtp, rtp_sess_ssrc(s->rtp));	if (err) {		DEBUG_WARNING("Send FIR: %m/n", err);	}}

/** * Get one frame from the jitter buffer * * @param jb   Jitter buffer * @param hdr  Returned RTP Header * @param mem  Pointer to memory object storage - referenced on success * * @return 0 if success, otherwise errorcode */int jbuf_get(struct jbuf *jb, struct rtp_header *hdr, void **mem){	struct frame *f;	if (!jb || !hdr || !mem)		return EINVAL;	STAT_INC(n_get);	if (jb->n <= jb->min || !jb->framel.head) {		DEBUG_INFO("not enough buffer frames - wait.. (n=%u min=%u)/n",			   jb->n, jb->min);		STAT_INC(n_underflow);		return ENOENT;	}	/* When we get one frame F[i], check that the next frame F[i+1]	   is present and have a seq no. of seq[i] + 1 !	   if not, we should consider that packet lost */	f = jb->framel.head->data;#if JBUF_STAT	/* Check timestamp of previously played frame */	if (jb->seq_get) {		const int16_t seq_diff = f->hdr.seq - jb->seq_get;		if (seq_less(f->hdr.seq, jb->seq_get)) {			DEBUG_WARNING("get: seq=%u too late/n", f->hdr.seq);		}		else if (seq_diff > 1) {			STAT_ADD(n_lost, 1);			DEBUG_INFO("get: n_lost: diff=%d,seq=%u,seq_get=%u/n",				   seq_diff, f->hdr.seq, jb->seq_get);		}	}	/* Update sequence number for 'get' */	jb->seq_get = f->hdr.seq;#endif	*hdr = f->hdr;	*mem = mem_ref(f->mem);	frame_deref(jb, f);	return 0;}

static int mod_srtp_init(void){	err_status_t err;	err = srtp_init();	if (err_status_ok != err) {		DEBUG_WARNING("srtp_init() failed (%H)/n",			      errstatus_print, err);		return ENOSYS;	}	menc_register(&menc_srtp_opt);	menc_register(&menc_srtp_mand);	menc_register(&menc_srtp_mandf);	return 0;}

jboolean JNICALL ScriptMethodsServerUINamespace::clearSuiDataSourceContainer(JNIEnv * env, jobject self, jint pageId, jstring dataSourceContainer){	JavaStringParam localDataSource(dataSourceContainer);	ServerUIPage * const p = ServerUIManager::getPage(pageId);	if(!p)	{		DEBUG_WARNING(true, ("SUI: Could not find page %d, cannot clear datasource", pageId));		return JNI_FALSE;	}	std::string ds;	JavaLibrary::convert(localDataSource, ds);	p->clearDataSourceContainer(ds);	return JNI_TRUE;}

int audio_decoder_set(struct audio *a, const struct aucodec *ac,		      int pt_rx, const char *params){	struct aurx *rx;	bool reset = false;	int err = 0;	if (!a || !ac)		return EINVAL;	rx = &a->rx;	reset = !aucodec_equal(ac, rx->ac);	if (ac != rx->ac) {		(void)re_fprintf(stderr, "Set audio decoder: %s %uHz %dch/n",				 ac->name, get_srate(ac), ac->ch);		rx->pt = pt_rx;		rx->ac = ac;		rx->dec = mem_deref(rx->dec);	}	if (ac->decupdh) {		err = ac->decupdh(&rx->dec, ac, params);		if (err) {			DEBUG_WARNING("alloc decoder: %m/n", err);			return err;		}	}	stream_set_srate(a->strm, get_srate(ac), get_srate(ac));	if (reset) {		rx->auplay = mem_deref(rx->auplay);		/* Reset audio filter chain */		list_flush(&a->filtl);		err |= audio_start(a);	}	return err;}

/** * Read a block of memory from a memory buffer * * @param mb   Memory buffer * @param buf  Buffer to read data to * @param size Size of buffer * * @return 0 if success, otherwise errorcode */int mbuf_read_mem(struct mbuf *mb, uint8_t *buf, size_t size){	if (!mb || !buf)		return EINVAL;	if (size > mbuf_get_left(mb)) {		DEBUG_WARNING("tried to read beyond mbuf end (%u > %u)/n",			      size, mbuf_get_left(mb));		return EOVERFLOW;	}	memcpy(buf, mb->buf + mb->pos, size);	mb->pos += size;	return 0;}

const char* inet_ntop(int af, const void *src, char *dst, size_t size){	switch (af) {	case AF_INET:		return inet_ntop4(src, dst, size);#ifdef HAVE_INET6	case AF_INET6:		return inet_ntop6(src, dst, size);#endif	default:		DEBUG_WARNING("inet_ntop: unknown address family %d/n", af);		return NULL;	}}

/** * Call the application event handler * * @param re     Poll state * @param fd     File descriptor * @param flags  Event flags */static void fd_handler(struct re *re, int fd, int flags){	const uint64_t tick = tmr_jiffies();	uint32_t diff;	DEBUG_INFO("event on fd=%d (flags=0x%02x).../n", fd, flags);	re->fhs[fd].fh(flags, re->fhs[fd].arg);	diff = (uint32_t)(tmr_jiffies() - tick);	if (diff > MAX_BLOCKING) {		DEBUG_WARNING("long async blocking: %u>%u ms (h=%p arg=%p)/n",			      diff, MAX_BLOCKING,			      re->fhs[fd].fh, re->fhs[fd].arg);	}}

static void decode_param(const struct pl *name, const struct pl *val,			 void *arg){	struct aucodec_st *st = arg;	int err;	if (0 == pl_strcasecmp(name, "bitrate")) {		st->bitrate = pl_u32(val) * 1000;	}	else if (0 == pl_strcasecmp(name, "frame-size")) {		st->frame_size = pl_u32(val);		if (st->frame_size & 0x1) {			DEBUG_WARNING("frame-size is NOT even: %u/n",				      st->frame_size);		}	}	else if (0 == pl_strcasecmp(name, "low-overhead")) {		struct pl fs, bpfv;		uint32_t i;		st->low_overhead = true;		err = re_regex(val->p, val->l, "[0-9]+/[0-9,]+", &fs, &bpfv);		if (err)			return;		st->frame_size = pl_u32(&fs);		for (i=0; i<ARRAY_SIZE(st->bpfv) && bpfv.l > 0; i++) {			struct pl bpf, co;			co.l = 0;			if (re_regex(bpfv.p, bpfv.l, "[0-9]+[,]*", &bpf, &co))				break;			pl_advance(&bpfv, bpf.l + co.l);			st->bpfv[i] = pl_u32(&bpf);		}		st->bpfn = i;	}	else {		DEBUG_NOTICE("unknown param: %r = %r/n", name, val);	}}

void rtcp_sess_rx_rtp(struct rtcp_sess *sess, uint16_t seq, uint32_t ts,		      uint32_t ssrc, size_t payload_size,		      const struct sa *peer){	struct rtp_member *mbr;	if (!sess)		return;	mbr = get_member(sess, ssrc);	if (!mbr) {		DEBUG_NOTICE("could not add member: 0x%08x/n", ssrc);		return;	}	if (!mbr->s) {		mbr->s = mem_zalloc(sizeof(*mbr->s), NULL);		if (!mbr->s) {			DEBUG_NOTICE("could not add sender: 0x%08x/n", ssrc);			return;		}		/* first packet - init sequence number */		source_init_seq(mbr->s, seq);		mbr->s->max_seq = seq - 1;		/* probation not used */		sa_cpy(&mbr->s->rtp_peer, peer);		++sess->senderc;	}	if (!source_update_seq(mbr->s, seq)) {		DEBUG_WARNING("rtp_update_seq() returned 0/n");	}	if (sess->srate_rx) {		uint32_t ts_arrive;		/* Convert from wall-clock time to timestamp units */		ts_arrive = (uint32_t)(tmr_jiffies()) * sess->srate_rx / 1000;		source_calc_jitter(mbr->s, ts, ts_arrive);	}	mbr->s->rtp_rx_bytes += payload_size;}

static int play_alloc(struct auplay_st **stp, struct auplay *ap,		      struct auplay_prm *prm, const char *device,		      auplay_write_h *wh, void *arg){	struct auplay_st *st;	int err;	int i;	(void)device;	if (play_dev_count < 1) {		DEBUG_WARNING("no winwave play devices/n");		return ENODEV;	}	st = mem_zalloc(sizeof(*st), auplay_destructor);	if (!st)		return ENOMEM;	st->ap  = mem_ref(ap);	st->wh  = wh;	st->arg = arg;	if (prm) {		prm->fmt = AUFMT_S16LE;		st->prm = *prm;	}	err = write_stream_open(st);	if (err)		goto out;	/* The write runs at 100ms intervals	 * prepare enough buffers to suite its needs	 */	for (i = 0; i < 5; i++)		dsp_write(st); out:	if (err)		mem_deref(st);	else		*stp = st;	return err;}

void CTcpSock::RunL(){	DEBUG_INFO("CTcpSock RunL (%p) iStatus=%d ts=%p/n", this,		   iStatus.Int(), ts);	/* This happens after calling cancel functions in socket */	if (iStatus == KErrCancel || iStatus == KErrAbort) {		iStatus = KErrNone;		return;	}	else if (iStatus != KErrNone) {		DEBUG_WARNING("RunL received iStatus %d/n", iStatus.Int());	}	/* Incoming CONNECT */	DEBUG_INFO("CTcpSock RunL (%p) Incoming CONNECT/n", this);	ts->tcp_conn_handler();}

static void tcp_conn_handler(const struct sa *peer, void *arg){	struct ice_lcand *lcand = arg;	int err;#if 0	trice_printf(lcand->icem,		    "[local=%H] incoming TCP-connect from %J/n",		    trice_cand_print, lcand, peer);#endif	err = trice_conn_alloc(&lcand->icem->connl, lcand->icem,			     lcand->attr.compid, false,			     &lcand->attr.addr, peer, lcand->ts, lcand->layer,			     tcpconn_frame_handler, lcand);	if (err) {		DEBUG_WARNING("ice_conn_alloc error (%m)/n", err);	}}

static void add_wave_in(struct ausrc_st *st){	MMRESULT   res;	struct dspbuf *db = &st->bufs[st->pos];	WAVEHDR *wh = &db->wh;	wh->lpData = (LPSTR)db->mb->buf;	wh->dwBufferLength = db->mb->size;	wh->dwBytesRecorded = 0;	wh->dwFlags = 0;	wh->dwUser = (DWORD_PTR) db->mb;	waveInPrepareHeader(st->wavein, wh, sizeof(WAVEHDR));	res = waveInAddBuffer(st->wavein, wh, sizeof(WAVEHDR));	if (res != MMSYSERR_NOERROR)		DEBUG_WARNING("add_wave_in: waveOutWrite fail: %08x/n", res);	INC_RPOS(st->pos);	st->inuse++;}

void ServerIntangibleObjectTemplate::_Ingredient::getIngredientsMax(SimpleIngredient &data, int index, bool versionOk) const{	const ServerIntangibleObjectTemplate::_Ingredient * base = NULL;	if (m_baseData != NULL)	{		base = dynamic_cast<const ServerIntangibleObjectTemplate::_Ingredient *>(m_baseData);	}	if (!m_ingredientsLoaded)	{		if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)		{			DEBUG_WARNING(true, ("Returning default value for missing parameter ingredients in template %s", DataResource::getName()));			return ;		}		else		{			DEBUG_FATAL(base == NULL, ("Template parameter ingredients has not been defined in template %s!", DataResource::getName()));			base->getIngredientsMax(data, index, versionOk);			return;		}	}	if (m_ingredientsAppend && base != NULL)	{		int baseCount = base->getIngredientsCount();		if (index < baseCount)			{				base->getIngredientsMax(data, index, versionOk);				return;			}		index -= baseCount;	}	DEBUG_FATAL(index < 0 || static_cast<size_t>(index) >= m_ingredients.size(), ("template param index out of range"));	const ObjectTemplate * structTemplate = (*m_ingredients[index]).getValue();	NOT_NULL(structTemplate);	const _SimpleIngredient *param = dynamic_cast<const _SimpleIngredient *>(structTemplate);	NOT_NULL(param);	data.name = param->getName(versionOk);	data.ingredient = param->getIngredient(versionOk);	data.count = param->getCountMax(versionOk);}	// ServerIntangibleObjectTemplate::_Ingredient::getIngredientsMax

/** * Debug all allocated memory objects */void mem_debug(void){#if MEM_DEBUG	uint32_t n;	mem_lock();	n = list_count(&meml);	mem_unlock();	if (!n)		return;	DEBUG_WARNING("Memory leaks (%u):/n", n);	mem_lock();	(void)list_apply(&meml, true, debug_handler, NULL);	mem_unlock();#endif}

void CUdpSocket::RunL(){	DEBUG_INFO("RunL iStatus=%d/n", iStatus.Int());	/* This happens after calling cancel functions in socket */	if (iStatus == KErrCancel || iStatus == KErrAbort) {		iStatus = KErrNone;	}	else if (iStatus == KErrGeneral) {		/* cache error code */		us->cerr = ECONNREFUSED;	}	else if (iStatus != KErrNone) {		DEBUG_WARNING("RunL received iStatus %d/n", iStatus.Int());	}	else if (iBufRx.Length()) {		us->recv();	}}

static void *read_thread(void *arg){	struct vidsrc_st *st = arg;	while (st->run) {		ssize_t n;		n = read(st->fd, st->mb->buf, st->mb->size);		if ((ssize_t)st->mb->size != n) {			DEBUG_WARNING("video read: %d -> %d bytes/n",				      st->mb->size, n);			continue;		}		call_frame_handler(st, st->mb->buf);	}	return NULL;}

void ServerManufactureSchematicObjectTemplate::getAttributesMax(SchematicAttribute &data, int index) const{	const ServerManufactureSchematicObjectTemplate * base = NULL;	if (m_baseData != NULL)	{		base = dynamic_cast<const ServerManufactureSchematicObjectTemplate *>(m_baseData);	}	if (!m_attributesLoaded)	{		if (ms_allowDefaultTemplateParams && /*!m_versionOk &&*/ base == NULL)		{			DEBUG_WARNING(true, ("Returning default value for missing parameter attributes in template %s", DataResource::getName()));			return ;		}		else		{			DEBUG_FATAL(base == NULL, ("Template parameter attributes has not been defined in template %s!", DataResource::getName()));			base->getAttributesMax(data, index);			return;		}	}	if (m_attributesAppend && base != NULL)	{		int baseCount = base->getAttributesCount();		if (index < baseCount)			{				base->getAttributesMax(data, index);				return;			}		index -= baseCount;	}	DEBUG_FATAL(index < 0 || static_cast<size_t>(index) >= m_attributes.size(), ("template param index out of range"));	const ObjectTemplate * structTemplate = (*m_attributes[index]).getValue();	NOT_NULL(structTemplate);	const _SchematicAttribute *param = dynamic_cast<const _SchematicAttribute *>(structTemplate);	NOT_NULL(param);	data.name = param->getName(m_versionOk);	data.value = param->getValueMax(m_versionOk);}	// ServerManufactureSchematicObjectTemplate::getAttributesMax

/** * Check List and Timer State Updates */void icem_checklist_update(struct icem *icem){	struct le *le;	bool compl;	int err = 0;	compl = iscompleted(icem);	if (!compl)		return;	/*	 * If there is not a pair in the valid list for each component of the	 * media stream, the state of the check list is set to Failed.	 */	for (le = icem->compl.head; le; le = le->next) {		struct icem_comp *comp = le->data;		if (!icem_candpair_find_compid(&icem->validl, comp->id)) {			DEBUG_WARNING("{%s.%u} no valid candidate pair"				      " (validlist=%u)/n",				      icem->name, comp->id,				      list_count(&icem->validl));			err = ENOENT;			break;		}		concluding_ice(comp);		if (!comp->cp_sel)			continue;		icem_comp_keepalive(comp, true);	}	icem->state = err ? CHECKLIST_FAILED : CHECKLIST_COMPLETED;	if (icem->chkh) {		icem->chkh(err, icem->ice->lrole == ROLE_CONTROLLING,			   icem->arg);	}}

static int read_stream_open(struct ausrc_st *st){	MMRESULT err;	WAVEFORMATEX  wfmt;	int i;	/* Open an audio INPUT stream. */	st->wavein = NULL;	st->pos = 0;	st->rdy = false;	st->stop = false;	for (i = 0; i < READ_BUFFERS; i++) {		memset(&st->bufs[i].wh, 0, sizeof(WAVEHDR));		st->bufs[i].mb = mbuf_alloc(2 * st->prm.frame_size);	}	wfmt.wFormatTag      = WAVE_FORMAT_PCM;	wfmt.nChannels       = st->prm.ch;	wfmt.nSamplesPerSec  = st->prm.srate;	wfmt.wBitsPerSample  = 16;	wfmt.nBlockAlign     = (st->prm.ch * wfmt.wBitsPerSample) / 8;	wfmt.nAvgBytesPerSec = wfmt.nSamplesPerSec * wfmt.nBlockAlign;	wfmt.cbSize          = 0;	err = waveInOpen(&st->wavein,			  WAVE_MAPPER,			  &wfmt,			  (DWORD_PTR) waveInCallback,			  (DWORD_PTR) st,			  CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT);	if (err != MMSYSERR_NOERROR) {		DEBUG_WARNING("waveInOpen: failed %d/n", err);		return EINVAL;	}	/* Prepare enough IN buffers to suite at least 50ms of data */	for (i = 0; i < READ_BUFFERS; i++)		add_wave_in(st);	waveInStart(st->wavein);	return 0;}

int trice_alloc(struct trice **icemp, const struct trice_conf *conf,	       bool controlling,	       const char *lufrag, const char *lpwd){	struct trice *icem;	int err = 0;	if (!icemp || !lufrag || !lpwd)		return EINVAL;	if (str_len(lufrag) < 4 || str_len(lpwd) < 22) {		DEBUG_WARNING("alloc: lufrag/lpwd is too short/n");		return EINVAL;	}	icem = mem_zalloc(sizeof(*icem), trice_destructor);	if (!icem)		return ENOMEM;	icem->conf = conf ? *conf : conf_default;	list_init(&icem->lcandl);	list_init(&icem->rcandl);	list_init(&icem->checkl);	list_init(&icem->validl);	icem->controlling = controlling;	icem->tiebrk = rand_u64();	err |= str_dup(&icem->lufrag, lufrag);	err |= str_dup(&icem->lpwd, lpwd);	if (err)		goto out; out:	if (err)		mem_deref(icem);	else		*icemp = icem;	return err;}

/** * Listen to a SIP Session socket for incoming connections * * @param sockp    Pointer to allocated SIP Session socket * @param sip      SIP Stack instance * @param htsize   Hashtable size * @param connh    Connection handler * @param arg      Handler argument * * @return 0 if success, otherwise errorcode */int sipsess_listen(struct sipsess_sock **sockp, struct sip *sip,		   int htsize, sipsess_conn_h *connh, void *arg){	struct sipsess_sock *sock;	int err;	DEBUG_WARNING("re.sipsess.listen.sipsess_listen()/n");	if (!sockp || !sip || !htsize)		return EINVAL;	sock = mem_zalloc(sizeof(*sock), destructor);	if (!sock)		return ENOMEM;	err = sip_listen(&sock->lsnr_resp, sip, false, response_handler, sock);	if (err)		goto out;	err = sip_listen(&sock->lsnr_req, sip, true, request_handler, sock);	if (err)		goto out;	err = hash_alloc(&sock->ht_sess, htsize);	if (err)		goto out;	err = hash_alloc(&sock->ht_ack, htsize);	if (err)		goto out;	sock->sip   = sip;	sock->connh = connh ? connh : internal_connect_handler;	sock->arg   = connh ? arg : sock; out:	if (err)		mem_deref(sock);	else		*sockp = sock;	return err;}

void stream_start_keepalive(struct stream *s){	const char *rtpkeep;	if (!s)		return;	rtpkeep = ua_param(call_get_ua(s->call), "rtpkeep");	s->rtpkeep = mem_deref(s->rtpkeep);	if (rtpkeep && sdp_media_rformat(s->sdp, NULL)) {		int err;		err = rtpkeep_alloc(&s->rtpkeep, rtpkeep,				    IPPROTO_UDP, s->rtp, s->sdp);		if (err) {			DEBUG_WARNING("rtpkeep_alloc failed: %m/n", err);		}	}}

/** * Decode SDP session attributes * * @param ice   ICE Session * @param name  Name of the SDP attribute * @param value Value of the SDP attribute (optional) * * @return 0 if success, otherwise errorcode */int ice_sdp_decode(struct ice *ice, const char *name, const char *value){	if (!ice)		return EINVAL;	if (0 == str_casecmp(name, ice_attr_lite)) {		if (ICE_MODE_LITE == ice->lmode) {			DEBUG_WARNING("we are lite, peer is also lite!/n");			return EPROTO;		}		ice->rmode = ICE_MODE_LITE;		ice->lrole = ROLE_CONTROLLING;	}	else if (0 == str_casecmp(name, ice_attr_ufrag))		return ufrag_decode(ice, value);	else if (0 == str_casecmp(name, ice_attr_pwd))		return pwd_decode(ice, value);	return 0;}

static void sniff_stun(struct mbuf *mb){	struct stun_msg *msg;	size_t pos;	int err;	pos = mb->pos;	err = stun_msg_decode(&msg, mb, NULL);	if (err) {		DEBUG_WARNING("could not decode STUN packet (%m)/n", err);		return;	}	stun_msg_attr_apply(msg, stun_attr_handler, 0);	(void)re_printf("/n");	mem_deref(msg);	mb->pos = pos;}

const StringId ServerIntangibleObjectTemplate::_SchematicAttribute::getName(bool versionOk, bool testData) const{#ifdef _DEBUGStringId testDataValue = DefaultStringId;#elseUNREF(testData);#endif	const ServerIntangibleObjectTemplate::_SchematicAttribute * base = NULL;	if (m_baseData != NULL)	{		base = dynamic_cast<const ServerIntangibleObjectTemplate::_SchematicAttribute *>(m_baseData);#ifdef _DEBUG		if (testData && base != NULL)			testDataValue = base->getName(true);#endif	}	if (!m_name.isLoaded())	{		if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)		{			DEBUG_WARNING(true, ("Returning default value for missing parameter name in template %s", DataResource::getName()));			return DefaultStringId;		}		else		{			DEBUG_FATAL(base == NULL, ("Template parameter name has not been defined in template %s!", DataResource::getName()));			return base->getName(versionOk);		}	}	const StringId value = m_name.getValue();#ifdef _DEBUG	if (testData && base != NULL)	{	}#endif	return value;}	// ServerIntangibleObjectTemplate::_SchematicAttribute::getName