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

nsresultSVGTransformList::SetValueFromString(const nsAString& aValue){    SVGTransformListParser parser(aValue);    if (!parser.Parse()) {        // there was a parse error.        return NS_ERROR_DOM_SYNTAX_ERR;    }    return CopyFrom(parser.GetTransformList());}

nsresult SVGPointList::SetValueFromString(const nsAString& aValue) {  // The spec says that the list is parsed and accepted up to the first error  // encountered, so we must call CopyFrom even if an error occurs. We still  // want to throw any error code from setAttribute if there's a problem  // though, so we must take care to return any error code.  nsresult rv = NS_OK;  SVGPointList temp;  nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace> tokenizer(      aValue, ',', nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);  while (tokenizer.hasMoreTokens()) {    const nsAString& token = tokenizer.nextToken();    RangedPtr<const char16_t> iter = SVGContentUtils::GetStartRangedPtr(token);    const RangedPtr<const char16_t> end =        SVGContentUtils::GetEndRangedPtr(token);    float x;    if (!SVGContentUtils::ParseNumber(iter, end, x)) {      rv = NS_ERROR_DOM_SYNTAX_ERR;      break;    }    float y;    if (iter == end) {      if (!tokenizer.hasMoreTokens() ||          !SVGContentUtils::ParseNumber(tokenizer.nextToken(), y)) {        rv = NS_ERROR_DOM_SYNTAX_ERR;        break;      }    } else {      // It's possible for the token to be 10-30 which has      // no separator but needs to be parsed as 10, -30      const nsAString& leftOver = Substring(iter.get(), end.get());      if (leftOver[0] != '-' || !SVGContentUtils::ParseNumber(leftOver, y)) {        rv = NS_ERROR_DOM_SYNTAX_ERR;        break;      }    }    temp.AppendItem(SVGPoint(x, y));  }  if (tokenizer.separatorAfterCurrentToken()) {    rv = NS_ERROR_DOM_SYNTAX_ERR;  // trailing comma  }  nsresult rv2 = CopyFrom(temp);  if (NS_FAILED(rv2)) {    return rv2;  // prioritize OOM error code over syntax errors  }  return rv;}

	WidgetLayout::WidgetLayout(const WidgetLayout& other):		ActorTransform(mnew Data()), anchorMin(this), anchorMax(this), offsetMin(this), offsetMax(this),		anchorLeft(this), anchorRight(this), anchorBottom(this), anchorTop(this), offsetLeft(this),		offsetBottom(this), offsetTop(this), minSize(this), minWidth(this), minHeight(this),		maxSize(this), maxWidth(this), maxHeight(this), weight(this), widthWeight(this),		heigthWeight(this), offsetRight(this)	{		mData = (Data*)ActorTransform::mData;		CopyFrom(other);		mCheckMinMaxFunc = other.mCheckMinMaxFunc;	}

static inline void _distpach_remote_service_cmsg(RpcServerImpl * impl, int fd, const char * buff, int ibuff){    dcrpc_msg_t rpc_msg;    if (!rpc_msg.Unpack(buff, ibuff)){        GLOG_ERR("unpack rpc msg error ! buff length:%d", ibuff);        return;    }    GLOG_TRA("recv [%d] [%s] [%s]", fd, rpc_msg.path().c_str() , rpc_msg.ShortDebugString().c_str());    auto it = impl->dispatcher.find(rpc_msg.path());    if (it == impl->dispatcher.end()){//not found        rpc_msg.clear_request();        rpc_msg.set_status(RpcMsg_StatusCode_RPC_STATUS_NOT_EXIST);    }    else {        rpc_msg.set_status(RpcMsg_StatusCode_RPC_STATUS_SUCCESS);                RpcValues args((const RpcValuesImpl &)(rpc_msg.request().args()));		RpcService * service = it->second;		uint64_t transac_cookie = rpc_msg.cookie().transaction();		if (service->isasync()){			if (transac_cookie == 0){				GLOG_ERR("transaction is 0 but in a async call ... %s", rpc_msg.Debug());				return;			}			else {				async_rpc_yield_call(impl, transac_cookie, fd, rpc_msg);				int ret = service->yield(transac_cookie,					args, *rpc_msg.mutable_response()->mutable_error(), fd);				rpc_msg.mutable_response()->set_status(ret);				if (ret == 0){					return;				}				else {					rpc_msg.clear_request();				}			}		}		else {			RpcValues result;			rpc_msg.mutable_response()->set_status(				service->call(result, args,                *rpc_msg.mutable_response()->mutable_error(), fd));			auto msg_result = rpc_msg.mutable_response()->mutable_result();			msg_result->CopyFrom(*(decltype(msg_result))result.data());			rpc_msg.clear_request();		}    }    if (rpc_msg.cookie().transaction() > 0){        _rpc_send_msg(impl, fd, rpc_msg);    }}

//handling open requestvoid open_handler(Msg *msg, int sender_pid){    //msg->ptr1 is pathname, msg->num1 is length of pathname, msg->num2 is proc_inode    char pathname[MAXPATHNAMELEN];    CopyFrom(sender_pid,pathname,msg->ptr1,msg->num1+1);    int open_inum = path_to_inum(pathname,msg->num1,msg->num2,0);    if (open_inum<=0) {        msg->type = ERROR;    }    else {        msg->num1 = open_inum;        inode_cache *n = read_inode(open_inum);        msg->num2 = n->data.reuse;    }}

//handling chdir requestvoid chdir_handler(Msg *msg, int sender_pid){    char pathname[MAXPATHNAMELEN];    CopyFrom(sender_pid,pathname,msg->ptr1,msg->num1+1);    int target_inum = path_to_inum(pathname,msg->num1,msg->num2,0);    if (target_inum<=0) {        perror("illegal destination directory!");        msg->type = ERROR;        return;    }    inode_cache *n = read_inode(target_inum);    if (n->data.type!=INODE_DIRECTORY) {        perror("trying to change current directory to a non-directory place");        msg->type = ERROR;        return;    }    msg->num1 = target_inum;}

CObjectImageArray &CObjectImageArray::operator= (const CObjectImageArray &Source)//	Operator =	{	if (m_pRotationOffset)		delete [] m_pRotationOffset;	if (m_pGlowImages)		delete [] m_pGlowImages;	if (m_pScaledImages)		delete [] m_pScaledImages;	CopyFrom(Source);	return *this;	}

 protocol::AccountAssetResponse PbQueryResponseFactory::serializeAccountAssetResponse(     const model::AccountAssetResponse &accountAssetResponse) const {   protocol::AccountAssetResponse pb_response;   auto pb_account_asset = pb_response.mutable_account_assets();   for (auto &asset: accountAssetResponse.acct_assets) {     auto pb_asset = new iroha::protocol::AccountAsset();     pb_asset->set_asset_id(         asset.asset_id);     pb_asset->set_account_id(         asset.account_id);     auto pb_amount = pb_asset->mutable_balance();     pb_amount->CopyFrom(         serializeAmount(asset.balance));     pb_account_asset->AddAllocated(pb_asset);   }   return pb_response; }

int	   RpcServer::reply(RpcService *, uint64_t cookie, const RpcValues & result, int ret, const char * error){	RpcServiceCallContext * ctx = async_rpc_get_context(impl, cookie);	if (ctx){		dcrpc_msg_t & rpc_msg = ctx->msg;		rpc_msg.mutable_response()->set_status(ret);		if (error){			rpc_msg.mutable_response()->set_error(error);		}		auto msg_result = rpc_msg.mutable_response()->mutable_result();		msg_result->CopyFrom(*(decltype(msg_result))result.data());		rpc_msg.clear_request();		ret = _rpc_send_msg(impl, ctx->fd, rpc_msg);		async_rpc_resume_call(impl, cookie);		return ret;	}	else {		return -1;	}}

nsresult SVGLengthList::SetValueFromString(const nsAString& aValue) {  SVGLengthList temp;  nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace> tokenizer(      aValue, ',', nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);  while (tokenizer.hasMoreTokens()) {    SVGLength length;    if (!length.SetValueFromString(tokenizer.nextToken())) {      return NS_ERROR_DOM_SYNTAX_ERR;    }    if (!temp.AppendItem(length)) {      return NS_ERROR_OUT_OF_MEMORY;    }  }  if (tokenizer.separatorAfterCurrentToken()) {    return NS_ERROR_DOM_SYNTAX_ERR;  // trailing comma  }  return CopyFrom(temp);}

WString WriteNamespace(List<WString>& currentNamespaces, List<WString>& namespaces, StreamWriter& writer){	vint common = 0;	for (vint i = 0; i < currentNamespaces.Count() && i < namespaces.Count(); i++)	{		if (currentNamespaces[i] == namespaces[i])		{			common++;		}		else		{			break;		}	}	for (vint i = 0; i < currentNamespaces.Count() - common; i++)	{		WString prefix;		for (vint j = 0; j < currentNamespaces.Count() - i - 1; j++)		{			prefix += L"/t";		}		writer.WriteLine(prefix + L"}");	}	WString prefix;	FOREACH_INDEXER(WString, ns, i, namespaces)	{		if (i >= common)		{			writer.WriteLine(prefix + L"namespace " + ns);			writer.WriteLine(prefix + L"{");		}		prefix += L"/t";	}	CopyFrom(currentNamespaces, namespaces);	return prefix;}

nsresultSVGNumberList::SetValueFromString(const nsAString& aValue){  SVGNumberList temp;  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace>    tokenizer(aValue, ',', nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);  while (tokenizer.hasMoreTokens()) {    float num;    if (!SVGContentUtils::ParseNumber(tokenizer.nextToken(), num)) {      return NS_ERROR_DOM_SYNTAX_ERR;    }    if (!temp.AppendItem(num)) {      return NS_ERROR_OUT_OF_MEMORY;    }  }  if (tokenizer.separatorAfterCurrentToken()) {    return NS_ERROR_DOM_SYNTAX_ERR; // trailing comma  }  return CopyFrom(temp);}

void UAssetImportData::Serialize(FArchive& Ar){	if (Ar.UE4Ver() >= VER_UE4_ASSET_IMPORT_DATA_AS_JSON)	{		FString Json;		if (Ar.IsLoading())		{			Ar << Json;			TOptional<FAssetImportInfo> Copy = FromJson(MoveTemp(Json));			if (Copy.IsSet())			{				CopyFrom(Copy.GetValue());			}		}		else if (Ar.IsSaving())		{			Json = ToJson();			Ar << Json;		}	}	Super::Serialize(Ar);}

/** /brief Loads the main UI theme, and a menu theme. * *  See also foundtheme(void), it will return true when called after *  this method if this method was successful. * *  /param menufile name of menu item xml file */void MythThemedMenu::Init(const QString &menufile){    if (!m_state->m_loaded)    {        if (m_state->Create())            m_foundtheme = true;    }    else        m_foundtheme = true;    if (!m_foundtheme)        return;    CopyFrom(m_state);    connect(m_buttonList, SIGNAL(itemSelected(MythUIButtonListItem*)),            SLOT(setButtonActive(MythUIButtonListItem*)));    connect(m_buttonList, SIGNAL(itemClicked(MythUIButtonListItem*)),            SLOT(buttonAction(MythUIButtonListItem*)));    if (!parseMenu(menufile))        m_foundtheme = false;}

nsresultSVGLengthList::SetValueFromString(const nsAString& aValue){  SVGLengthList temp;  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace>    tokenizer(aValue, ',', nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);  nsCAutoString str;  // outside loop to minimize memory churn  while (tokenizer.hasMoreTokens()) {    SVGLength length;    if (!length.SetValueFromString(tokenizer.nextToken())) {      return NS_ERROR_DOM_SYNTAX_ERR;    }    if (!temp.AppendItem(length)) {      return NS_ERROR_OUT_OF_MEMORY;    }  }  if (tokenizer.lastTokenEndedWithSeparator()) {    return NS_ERROR_DOM_SYNTAX_ERR; // trailing comma  }  return CopyFrom(temp);}

int main (int argc, char **argv){			char pname[MAXPATHNAMELEN];	char *temp_buff;	int pid;	struct my_msg msg;	struct read_struct msg_read;	struct read_struct msg_write;	struct stat_struct msg_stat;	struct old_new msg_link;	struct Stat res_stat;	struct readlink msg_readlink;	struct seek_struct msg_seek;	printf("/nYFS: Started File Server");	Initialize_Server();	if (Fork() == 0) {	printf("/nCHILD/n");	pid=Exec(argv[1],argv);	printf("/nval returned by exec is %d",pid);	return 0;    	}    	else	 printf("/nPARENT/n");	while(1)	{		pid=Receive(&msg);		//printf("/nInside while");		switch(msg.type)		{	case CREATE:		//for create,type=1,data2=inode of current dir,ptr=ptr to path			{	printf("/nInside Server Create");				CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN);				msg.data2=Server_Create(pname,msg.data2);				printf("/nInside Server Returning %d",msg.data2);				if(msg.data2!=ERROR)					msg.type=0;				else					msg.type=ERROR;				printf("/nInside Server Returning %d",msg.type);				Reply(&msg,pid);				break;			}			case OPEN:		//for Open,type=1,data2=inode of current dir,ptr=ptr to path			{				CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN);				msg.data2=Server_Open(pname,msg.data2);				printf("/nVal returned by open is %d/n",msg.data2);				if(msg.data2!=ERROR)					msg.type=0;				else					msg.type=ERROR;				printf("/nInside Server Returning %d/n",msg.type);				Reply(&msg,pid);				break;			}			case MKDIR:		//for MkDir,type=1,data2=inode of current dir,ptr=ptr to path			{				CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN);				msg.data2=Server_MkDir(pname,msg.data2);				printf("/nInside Server MkDir with name as %s and curr inode %d/n",pname,msg.data2);				if(msg.data2!=ERROR)					msg.type=0;				else					msg.type=ERROR;				Reply(&msg,pid);				break;			}			case CHDIR:		//for ChDir,type=1,data2=inode of current dir,ptr=ptr to new dir			{				CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN);				printf("/nInside Server ChDir with name as %s and curr inode %d/n",pname,msg.data2);				msg.data2=Server_ChDir(pname,msg.data2);				if(msg.data2!=ERROR)					msg.type=0;				else					msg.type=ERROR;				Reply(&msg,pid);				break;			}			case RMDIR:		//for ChDir,type=1,data2=inode of current dir,ptr=ptr to dir			{				CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN);				msg.type=Server_RmDir(pname,msg.data2);				Reply((void *)&msg,pid);				break;			}			case READ:			{					CopyFrom(pid,(void *)&msg_read,msg.ptr,sizeof(struct read_struct));				temp_buff=(char *)malloc(msg_read.len+1);				msg.type=Server_Read(msg.data2,msg_read.len,msg_read.offset,temp_buff);//.........这里部分代码省略.........

	Guid& Guid::operator=(const Guid& other)	{		CopyFrom(other);		return *this;	}

ByteQueue & ByteQueue::operator=(const ByteQueue &rhs){	Destroy();	CopyFrom(rhs);	return *this;}

ByteQueue::ByteQueue(const ByteQueue &copy){	CopyFrom(copy);}

 Call::Call(const Call& other) :ISyntaxComponent(ISyntaxComponent::TYPE_CALL) {   CopyFrom(other); }

nsresult SVGTransformList::CopyFrom(const SVGTransformList& rhs) {  return CopyFrom(rhs.mItems);}

void               P3DMaterialDef::operator =                                      (const P3DMaterialDef                                                          &Source) {  CopyFrom(&Source); }

nsresultSVGPointList::SetValueFromString(const nsAString& aValue){  // The spec says that the list is parsed and accepted up to the first error  // encountered, so we must call CopyFrom even if an error occurs. We still  // want to throw any error code from setAttribute if there's a problem  // though, so we must take care to return any error code.  nsresult rv = NS_OK;  SVGPointList temp;  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace>    tokenizer(aValue, ',', nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);  nsAutoCString str1, str2;  // outside loop to minimize memory churn  while (tokenizer.hasMoreTokens()) {    CopyUTF16toUTF8(tokenizer.nextToken(), str1);    const char *token1 = str1.get();    if (*token1 == '/0') {      rv = NS_ERROR_DOM_SYNTAX_ERR;      break;    }    char *end;    float x = float(PR_strtod(token1, &end));    if (end == token1 || !NS_finite(x)) {      rv = NS_ERROR_DOM_SYNTAX_ERR;      break;    }    const char *token2;    if (*end == '-') {      // It's possible for the token to be 10-30 which has      // no separator but needs to be parsed as 10, -30      token2 = end;    } else {      if (!tokenizer.hasMoreTokens()) {        rv = NS_ERROR_DOM_SYNTAX_ERR;        break;      }      CopyUTF16toUTF8(tokenizer.nextToken(), str2);      token2 = str2.get();      if (*token2 == '/0') {        rv = NS_ERROR_DOM_SYNTAX_ERR;        break;      }    }    float y = float(PR_strtod(token2, &end));    if (*end != '/0' || !NS_finite(y)) {      rv = NS_ERROR_DOM_SYNTAX_ERR;      break;    }    temp.AppendItem(SVGPoint(x, y));  }  if (tokenizer.lastTokenEndedWithSeparator()) {    rv = NS_ERROR_DOM_SYNTAX_ERR; // trailing comma  }  nsresult rv2 = CopyFrom(temp);  if (NS_FAILED(rv2)) {    return rv2; // prioritize OOM error code over syntax errors  }  return rv;}

	SafeArray::SafeArray(const SafeArray& other) :		m_safeArray(nullptr)	{		CopyFrom(other);	}

ECode CCellSignalStrengthGsm::constructor(    /* [in] */ ICellSignalStrengthGsm* css){    return CopyFrom(css);}

void CMatrix::operator = (const CMatrix& right){    CopyFrom(right);}

void AssOverrideParameter::operator= (const AssOverrideParameter &param) {	CopyFrom(param);}

	SafeArray& SafeArray::operator=(const SafeArray& other)	{		CopyFrom(other);		return *this;	}