C++ data_entry::set_data方法代码示例

      int item_manager::get_items(tair_manager *tair_mgr,int area,data_entry& key,int offset,int count,data_entry& value /*out*/,int type)
      {
         if(area < 0 || key.get_size() <= 0 || count < 1){
            return TAIR_RETURN_INVALID_ARGUMENT;
         }
         data_entry tmp_value;
         vector<any> items;
         int ret = -1;
         log_debug("start get_items:type:%d",type);
         if (  (ret = __get_items(tair_mgr,area,key,tmp_value,items,type)) < 0){
            log_debug("__get_items failed:%d",ret);
            return ret;
         }

         vector<any>::iterator start;
         vector<any>::iterator end;

         if ( (ret = __set_region(items,offset,count,start,end)) < 0){
            log_debug("__set_region failed");
            return ret;
         }
         int result_count = end - start;
         uint32_t attr = get_attribute(tmp_value);
         uint32_t result_attr = 0;
         SET_VAL_COUNT(result_attr,result_count);
         SET_VAL_TYPE(result_attr,VAL_TYPE(attr));

         string result( reinterpret_cast<char *>(&result_attr),sizeof(uint32_t));//just reserve space
         if( !prepare_serialize(VAL_TYPE(attr),start,end,result) ){
            log_debug("prepare_serialize failed");
            return TAIR_RETURN_SERIALIZE_ERROR;
         }
         log_debug("end get_items: success");
         value.set_data(result.data(),result.size(),true);
         set_attribute(value,result_attr);
         return TAIR_RETURN_SUCCESS;
      }

      int item_manager::add_items(tair_manager *tair_mgr,int area,data_entry& key,data_entry& value,int max_count,int expired)
      {
         if( UNLIKELY(area < 0 || max_count <= 0)){
            return TAIR_RETURN_INVALID_ARGUMENT;
         }

         if( UNLIKELY(max_count > item_manager::MAX_ITEMS)){
            max_count = item_manager::MAX_ITEMS;
         }

         int version = key.get_version();
         data_entry old_value;
         log_debug("start add_items");
         if( tair_mgr->get(area,key,old_value) != TAIR_RETURN_SUCCESS){ // is new
            tair_mgr->get_storage_manager()->set_flag(value.data_meta.flag, TAIR_ITEM_FLAG_ITEM);
            // value.data_meta.flag |= TAIR_ITEM_FLAG_ITEM;
            uint32_t _new_attr = get_attribute(value);
            string _new_result(reinterpret_cast<char *>(&_new_attr),sizeof(_new_attr)); //just reserve space
            int _new_items_no = new_items(value,VAL_TYPE(_new_attr),max_count,_new_result);
            if(_new_items_no < 0){
               return TAIR_RETURN_SERIALIZE_ERROR;
            }
            SET_VAL_COUNT(_new_attr,_new_items_no);
            value.set_data(_new_result.data(),_new_result.size(),true); //we must set the value back.
            set_attribute(value,_new_attr);
            return tair_mgr->put(area,key,value,expired);
         }
         //whether the version is matched
         if( (version != 0) && (version != old_value.get_version())){
            return TAIR_RETURN_VERSION_ERROR;
         }

         //the get method will set the flag
         if( !CAN_OVERRIDE(old_value.data_meta.flag,TAIR_ITEM_FLAG_ITEM) ){
            log_debug("cann't override old value,old_value's flag:%d\n",old_value.data_meta.flag);
            return TAIR_RETURN_CANNOT_OVERRIDE;
         }

         uint8_t old_flag = 0;
         if (tair_mgr->get_storage_manager()->test_flag(old_value.data_meta.flag, TAIR_ITEM_FLAG_DELETED)) {
         // if (IS_DELETED(old_value.data_meta.flag)){ // in migrate
            old_flag = TAIR_ITEM_FLAG_DELETED;
         }

         //get and deal with attribute of old_value & value
         uint32_t old_attr = get_attribute(old_value);
         uint32_t new_attr = get_attribute(value);
         if( (VAL_TYPE(new_attr)) != VAL_TYPE(old_attr)){
            log_debug("type not match,old_attr:%u,new_attr:%u",old_attr,new_attr);
            return TAIR_RETURN_TYPE_NOT_MATCH;
         }

         //deserialize and merge old_value & value
         uint32_t attr = 0;
         string result(reinterpret_cast<char *>(&attr),sizeof(attr)); //just reserve space
         int item_num = -1;
         if( (item_num = merge_items(old_value,value,VAL_TYPE(new_attr),max_count,result)) < 0 ){
            log_debug("merge_items failed");
            return TAIR_RETURN_SERIALIZE_ERROR;
         }
         SET_VAL_COUNT(attr,item_num);
         SET_VAL_TYPE(attr,(VAL_TYPE(new_attr)));

         data_entry final_value;
         final_value.set_data(result.data(),result.size(),true);
         final_value.set_version(version);
         tair_mgr->get_storage_manager()->set_flag(final_value.data_meta.flag, TAIR_ITEM_FLAG_ITEM);
         tair_mgr->get_storage_manager()->set_flag(final_value.data_meta.flag, old_flag);

         log_debug("final_value:%s",get_items_addr(final_value));

         set_attribute(final_value,attr); //set attribute
         //put the new value into the storage & return
         return tair_mgr->put(area,key,final_value,expired);
      }