Improvements for XML format, Support for RemoteHandle.

XML format now can use Include attribute in any XML tag to address
external files.

Added mechanism to name meshes and retrive meshes by name.

Added feature to store data of RemoteHandle type that allows to address
elements on another mesh. Loading this data type from files is still
awkward.

Examples/OldDrawGrid/main.cpp

@@ -3501,6 +3501,17 @@ void draw_screen()
 						}
 						break;
 					}
+        case DATA_REMOTE_REFERENCE:
+					{
+						Storage::remote_reference_array arr = e->RemoteReferenceArray(*t);
+						for(INMOST_DATA_ENUM_TYPE k = 0; k < arr.size(); k++) 
+						{
+              if(arr.at(k).first == NULL || arr.at(k).second == InvalidHandle()) sprintf(temp,"%s NULL",str);
+              else sprintf(temp,"%s %p:%s:%d",str,arr[k]->GetMeshLink(),ElementTypeName(arr[k]->GetElementType()),arr[k]->LocalID());
+							strcpy(str,temp);
+						}
+						break;
+					}
 				}
 				sprintf(temp,"%s %s %s",t->GetTagName().c_str(),DataTypeName(t->GetDataType()),str);
 				strcpy(str,temp);

Source/Data/storage.cpp

@@ -14,6 +14,15 @@ namespace INMOST
 		return *this;
 	}
 	
+  Element MakeElement(const RemoteHandleType & rh)
+  {
+    return Element(rh.first,rh.second);
+  }
+
+  Element MakeElementRef(RemoteHandleType & rh)
+  {
+    return Element(rh.first,&rh.second);
+  }
 	
 	Element Storage::reference_array::operator [](size_type n)  
 	{
@@ -49,6 +58,42 @@ namespace INMOST
   {
     shell<reference>::push_back(ref->GetHandle());
   }
+
+  Element Storage::remote_reference_array::operator [](size_type n)  
+	{
+    
+		return MakeElementRef(shell<remote_reference>::operator[](n));
+	}
+
+	Element Storage::remote_reference_array::operator [](size_type n) const 
+	{
+		return MakeElement(shell<remote_reference>::operator[](n));
+	}
+
+	Element Storage::remote_reference_array::iterator::operator->()
+	{
+		return MakeElementRef(shell<remote_reference>::iterator::operator *());
+	}
+
+	Element Storage::remote_reference_array::const_iterator::operator->()
+	{
+		return MakeElement(shell<remote_reference>::const_iterator::operator *());
+	}
+	
+	Element Storage::remote_reference_array::reverse_iterator::operator->()
+	{
+		return MakeElementRef(shell<remote_reference>::reverse_iterator::operator *());
+	}
+
+	Element Storage::remote_reference_array::const_reverse_iterator::operator->()
+	{
+		return MakeElement(shell<remote_reference>::const_reverse_iterator::operator *());
+	}
+
+  void Storage::remote_reference_array::push_back(const Storage & ref) 
+  {
+    shell<remote_reference>::push_back(RemoteHandleType(ref->GetMeshLink(),ref->GetHandle()));
+  }
 }
 
 #endif

Source/Data/tag.cpp

@@ -11,6 +11,7 @@ namespace INMOST
 			case DATA_INTEGER:   return "INTEGER";
 			case DATA_BULK:      return "BULK";
 			case DATA_REFERENCE: return "REFERENCE";
+      case DATA_REMOTE_REFERENCE: return "REMOTE_REFERENCE";
 #if defined(USE_AUTODIFF)
       case DATA_VARIABLE:  return "VARIABLE";
 #endif
@@ -26,6 +27,7 @@ namespace INMOST
 			case DATA_BULK:      return sizeof(INMOST_DATA_BULK_TYPE);
 			case DATA_INTEGER:   return sizeof(INMOST_DATA_INTEGER_TYPE);
 			case DATA_REAL:      return sizeof(INMOST_DATA_REAL_TYPE);
+      case DATA_REMOTE_REFERENCE:      return sizeof(RemoteHandleType);
 			case DATA_REFERENCE: return sizeof(HandleType);
 #if defined(USE_AUTODIFF)
       case DATA_VARIABLE:  return sizeof(variable);
@@ -43,6 +45,7 @@ namespace INMOST
 			case DATA_INTEGER:   return sizeof(inner_integer_array);
 			case DATA_BULK:      return sizeof(inner_bulk_array);
 			case DATA_REFERENCE: return sizeof(inner_reference_array);
+      case DATA_REMOTE_REFERENCE: return sizeof(inner_remote_reference_array);
 #if defined(USE_AUTODIFF)
       case DATA_VARIABLE:  return sizeof(inner_variable_array);
 #endif
@@ -79,6 +82,8 @@ namespace INMOST
 			else if( type == DATA_INTEGER )   new (adata) inner_integer_array  (*static_cast<const inner_integer_array   * >(bdata));
 			else if( type == DATA_BULK )      new (adata) inner_bulk_array     (*static_cast<const inner_bulk_array      * >(bdata));
 			else if( type == DATA_REFERENCE ) new (adata) inner_reference_array(*static_cast<const inner_reference_array * >(bdata));
+      else if( type == DATA_REMOTE_REFERENCE ) 
+                                        new (adata) inner_remote_reference_array(*static_cast<const inner_remote_reference_array * >(bdata));
 #if defined(USE_AUTODIFF)
       else if( type == DATA_VARIABLE )  new (adata) inner_variable_array (*static_cast<const inner_variable_array  * >(bdata));
 #endif
@@ -119,6 +124,11 @@ namespace INMOST
 				(*static_cast<inner_reference_array *> (adata)).~inner_reference_array();
 				new (adata) inner_reference_array();
 			}
+      else if( type == DATA_REMOTE_REFERENCE ) 
+			{
+				(*static_cast<inner_remote_reference_array *> (adata)).~inner_remote_reference_array();
+				new (adata) inner_remote_reference_array();
+			}
 #if defined(USE_AUTODIFF)
       else if( type == DATA_VARIABLE ) 
       {
@@ -189,6 +199,7 @@ namespace INMOST
 			case DATA_REAL:      mem->bulk_data_type = INMOST_MPI_DATA_REAL_TYPE;    break;
 			case DATA_INTEGER:   mem->bulk_data_type = INMOST_MPI_DATA_INTEGER_TYPE; break;
 			case DATA_REFERENCE: mem->bulk_data_type = INMOST_MPI_DATA_ENUM_TYPE;    break;
+      case DATA_REMOTE_REFERENCE: mem->bulk_data_type = INMOST_MPI_DATATYPE_NULL;    break; //should never send this
 #if defined(USE_AUTODIFF)
       case DATA_VARIABLE:
         if( !Sparse::HaveRowEntryType() ) Sparse::CreateRowEntryType();
@@ -498,6 +509,8 @@ namespace INMOST
 					case DATA_INTEGER:   for(INMOST_DATA_ENUM_TYPE it = new_size; it < old_size; ++it) {void * p = static_cast<void *>(&arr[it]); if( p != NULL ) (*static_cast<inner_integer_array   *>( p )).~inner_integer_array();  } break;
 					case DATA_BULK:      for(INMOST_DATA_ENUM_TYPE it = new_size; it < old_size; ++it) {void * p = static_cast<void *>(&arr[it]); if( p != NULL ) (*static_cast<inner_bulk_array      *>( p )).~inner_bulk_array();     } break;
 					case DATA_REFERENCE: for(INMOST_DATA_ENUM_TYPE it = new_size; it < old_size; ++it) {void * p = static_cast<void *>(&arr[it]); if( p != NULL ) (*static_cast<inner_reference_array *>( p )).~inner_reference_array();} break;
+          case DATA_REMOTE_REFERENCE: 
+                               for(INMOST_DATA_ENUM_TYPE it = new_size; it < old_size; ++it) {void * p = static_cast<void *>(&arr[it]); if( p != NULL ) (*static_cast<inner_remote_reference_array *>( p )).~inner_remote_reference_array();} break;
 #if defined(USE_AUTODIFF)
           case DATA_VARIABLE:  for(INMOST_DATA_ENUM_TYPE it = new_size; it < old_size; ++it) {void * p = static_cast<void *>(&arr[it]); if( p != NULL ) (*static_cast<inner_variable_array  *>( p )).~inner_variable_array(); } break;
 #endif
@@ -518,6 +531,8 @@ namespace INMOST
 				case DATA_INTEGER:   for(INMOST_DATA_ENUM_TYPE it = old_size; it < new_size; ++it) new ( &arr[it] ) inner_integer_array();   break;
 				case DATA_BULK:      for(INMOST_DATA_ENUM_TYPE it = old_size; it < new_size; ++it) new ( &arr[it] ) inner_bulk_array();      break;
 				case DATA_REFERENCE: for(INMOST_DATA_ENUM_TYPE it = old_size; it < new_size; ++it) new ( &arr[it] ) inner_reference_array(); break;
+        case DATA_REMOTE_REFERENCE: 
+                             for(INMOST_DATA_ENUM_TYPE it = old_size; it < new_size; ++it) new ( &arr[it] ) inner_remote_reference_array(); break;
 #if defined(USE_AUTODIFF)
         case DATA_VARIABLE:  for(INMOST_DATA_ENUM_TYPE it = old_size; it < new_size; ++it) new ( &arr[it] ) inner_variable_array();  break;
 #endif

Source/IO/mesh_gmv_file.cpp

@@ -91,7 +91,15 @@ namespace INMOST
 		{
 			if( etype == EDGE ) continue;
 			for(Mesh::iteratorTag t = BeginTag(); t != EndTag(); t++) 
-				if( t->isDefined(etype) && t->GetSize() == 1 && !t->isSparse(etype) && t->GetTagName().substr(0,9) != "PROTECTED" && t->GetDataType() != DATA_REFERENCE )
+				if( t->isDefined(etype) && 
+            t->GetSize() == 1 && 
+            !t->isSparse(etype) && 
+            t->GetTagName().substr(0,9) != "PROTECTED" && 
+            t->GetDataType() != DATA_REFERENCE &&
+#if defined(USE_AUTODIFF)
+            t->GetDataType() != DATA_VARIABLE &&
+#endif
+            t->GetDataType() != DATA_REMOTE_REFERENCE)
 				{
 					sprintf(keyword,"%s",t->GetTagName().substr(0,8).c_str());
 					fwrite(keyword,1,8,file);
@@ -124,7 +132,14 @@ namespace INMOST
 		{
 			if( etype == EDGE ) continue;
 			for(Mesh::iteratorTag t = BeginTag(); t != EndTag(); t++) 
-				if( t->isDefined(etype) && t->GetSize() == 1 && t->isSparse(etype) && t->GetDataType() != DATA_REFERENCE && t->GetDataType() != DATA_REFERENCE)
+				if( t->isDefined(etype) && 
+            t->GetSize() == 1 && 
+            t->isSparse(etype) && 
+            t->GetDataType() != DATA_REFERENCE && 
+#if defined(USE_AUTODIFF)
+            t->GetDataType() != DATA_VARIABLE &&
+#endif
+            t->GetDataType() != DATA_REMOTE_REFERENCE)
 				{
 					Storage::integer temp;
 					keynum = 0;
@@ -211,7 +226,16 @@ namespace INMOST
 		{
 			if( etype == EDGE ) continue;
 			for(Mesh::iteratorTag t = BeginTag(); t != EndTag(); t++) 
-				if( t->isDefined(etype) && t->GetSize() != 1 && t->GetSize() != ENUMUNDEF && !t->isSparse(etype) && t->GetDataType() != DATA_REFERENCE)
+				if( t->isDefined(etype) && 
+            t->GetSize() != 1 && 
+            t->GetSize() != ENUMUNDEF && 
+            !t->isSparse(etype) && 
+            t->GetDataType() != DATA_REFERENCE &&
+#if defined(USE_AUTODIFF)
+            t->GetDataType() != DATA_VARIABLE &&
+#endif
+            t->GetDataType() != DATA_REMOTE_REFERENCE
+            )
 				{
 					sprintf(keyword,"%s",t->GetTagName().substr(0,8).c_str());
 					fwrite(keyword,1,8,file);

Source/IO/mesh_pmf_file.cpp

@@ -324,6 +324,23 @@ namespace INMOST
 										else out.put(NONE);
 									}
 								} break;
+              case DATA_REMOTE_REFERENCE:
+								{
+									Storage::remote_reference_array arr = it->RemoteReferenceArray(*jt);
+									for(k = 0; k < recsize; k++)
+									{
+										if( arr[k].isValid() )
+										{
+                      uconv.write_iValue(out,arr[k].GetMeshLink()->GetMeshName().size());
+                      out.write(arr[k].GetMeshLink()->GetMeshName().c_str(),arr[k].GetMeshLink()->GetMeshName().size());
+											wetype = arr[k].GetElementType();
+											out.put(wetype);
+											lid = IntegerDF(arr[k]->GetHandle(),set_id);
+											uconv.write_iValue(out,lid);
+										}
+										else out.put(NONE);
+									}
+								} break;
 #if defined(USE_AUTODIFF)
               case DATA_VARIABLE:
 								{
@@ -1213,6 +1230,32 @@ namespace INMOST
 											else arr.at(k) = InvalidHandle();
 										}
 									} break;
+                case DATA_REMOTE_REFERENCE: 
+									{
+										Storage::remote_reference_array arr = RemoteReferenceArray(he,*jt);
+										for(k = 0; k < recsize; k++)
+										{
+                      INMOST_DATA_ENUM_TYPE size;
+                      std::vector<char> name;
+                      uconv.read_iValue(in,size);
+                      name.resize(size);
+                      if( !name.empty() ) in.read(&name[0],size);
+                      else std::cout << __FILE__ << ":" << __LINE__ << " Mesh of the name was not specified" << std::endl;
+                      arr.at(k).first = GetMesh(std::string(name.begin(),name.end()));
+                      if( arr.at(k).first == NULL )
+                        std::cout << __FILE__ << ":" << __LINE__ << " Mesh with the name " << std::string(name.begin(),name.end()) << " do not exist, you should create the mesh with this name first" << std::endl;
+											char type;
+											in.get(type);
+											if( in.eof() ) std::cout << __FILE__ << ":" << __LINE__ << " Unexpected end of file! " << tags[j].GetTagName() << " " << ElementTypeName(etype) << " " << (sparse? "sparse" : "dense") << std::endl;
+											if (type != NONE)
+											{
+												uconv.read_iValue(in, lid);
+												if( in.eof() ) std::cout << __FILE__ << ":" << __LINE__ << " Unexpected end of file! " << tags[j].GetTagName() << " " << ElementTypeName(etype) << " " << (sparse? "sparse" : "dense") << std::endl;
+                        arr.at(k).second = ComposeHandle(type,lid);
+											}
+                      else arr.at(k).second = InvalidHandle();
+										}
+									} break;
 #if defined(USE_AUTODIFF)
                 case DATA_VARIABLE:
                   {

Source/IO/mesh_vtk_file.cpp

@@ -231,8 +231,18 @@ safe_output:
 			{
 				Tag t = GetTag(tag_names[i]);
 				//printf("%s %d %d %d\n",tag_names[i].c_str(),t.isDefined(CELL),!t.isSparse(CELL),t.GetDataType() != DATA_BULK);
-				if( t.isDefined(CELL) && !t.isSparse(CELL) && t.GetDataType() != DATA_BULK && t.GetDataType() != DATA_REFERENCE &&
-					  t != CoordsTag() && t != SharedTag() && t != SendtoTag() && t != ProcessorsTag())
+				if( t.isDefined(CELL) && 
+            !t.isSparse(CELL) && 
+            t.GetDataType() != DATA_BULK && 
+            t.GetDataType() != DATA_REFERENCE &&
+            t.GetDataType() != DATA_REMOTE_REFERENCE &&
+#if defined(USE_AUTODIFF)
+            t.GetDataType() != DATA_VARIABLE &&
+#endif
+					  t != CoordsTag() && 
+            t != SharedTag() && 
+            t != SendtoTag() && 
+            t != ProcessorsTag())
 				{
 					//printf("added!\n");
 					tags.push_back(t);
@@ -285,8 +295,18 @@ safe_output:
 			for(unsigned int i = 0; i < tag_names.size(); i++)
 			{
 				Tag t = GetTag(tag_names[i]);
-				if( t.isDefined(NODE) && !t.isSparse(NODE) && t.GetDataType() != DATA_BULK && t.GetDataType() != DATA_REFERENCE &&
-					  t != CoordsTag() && t != SharedTag() && t != SendtoTag() && t != ProcessorsTag())
+				if( t.isDefined(NODE) && 
+            !t.isSparse(NODE) && 
+            t.GetDataType() != DATA_BULK && 
+            t.GetDataType() != DATA_REFERENCE &&
+            t.GetDataType() != DATA_REMOTE_REFERENCE &&
+#if defined(USE_AUTODIFF)
+            t.GetDataType() != DATA_VARIABLE &&
+#endif
+					  t != CoordsTag() && 
+            t != SharedTag() && 
+            t != SendtoTag() && 
+            t != ProcessorsTag())
 					tags.push_back(t);
 			}
 				

Source/Mesh/mesh.cpp

@@ -5,11 +5,10 @@
 
 namespace INMOST
 {
-
-#if defined(USE_PARALLEL_WRITE_TIME)
-	static std::vector<Mesh *> allocated_meshes;
+  static std::vector<Mesh *> allocated_meshes;
 
 
+#if defined(USE_PARALLEL_WRITE_TIME)
 	void Mesh::AtExit(void)
 	{
 		while(!allocated_meshes.empty())
@@ -23,6 +22,21 @@ namespace INMOST
 	}
 #endif //USE_PARALLEL_WRITE_TIME
 
+  std::string Mesh::GetMeshName()
+  {
+    return name;
+  }
+  void Mesh::SetMeshName(std::string new_name)
+  {
+    name = new_name;
+  }
+  Mesh * Mesh::GetMesh(std::string name)
+  {
+    for(int q = 0; q < (int)allocated_meshes.size(); ++q)
+      if( allocated_meshes[q]->GetMeshName() == name )
+        return allocated_meshes[q];
+    return NULL;
+  }
 
 	const char * TopologyCheckNotifyString(TopologyCheck c)
 	{
@@ -77,11 +91,10 @@ namespace INMOST
 		}
 		return "UNKNOWN";
 	}
-		
-	Mesh::Mesh()
-	:TagManager(), Storage(NULL,ComposeHandle(MESH,0))
-	{
-		m_link = this;
+
+  void Mesh::Init(std::string name)
+  {
+    m_link = this;
 		integer selfid = TieElement(5);
 		assert(selfid == 0);
 		dim = 3;
@@ -123,8 +136,23 @@ namespace INMOST
 		out_time << "<Debug>" << std::endl;
 		tab = 1;
 		func_id = 0;
-		allocated_meshes.push_back(this);
 #endif
+    allocated_meshes.push_back(this);
+  }
+		
+	Mesh::Mesh()
+	:TagManager(), Storage(NULL,ComposeHandle(MESH,0))
+	{
+    std::stringstream tmp;
+    tmp << "Mesh" << allocated_meshes.size();
+    name = tmp.str();
+    Init(name);
+	}
+
+  Mesh::Mesh(std::string name)
+	:TagManager(), Storage(NULL,ComposeHandle(MESH,0))
+	{
+    Init(name);
 	}
 
   bool Mesh::GetPrivateMarker(HandleType h, MarkerType n) const
@@ -243,7 +271,11 @@ namespace INMOST
 	Mesh::Mesh(const Mesh & other)
 	:TagManager(other),Storage(NULL,ComposeHandle(MESH,0))
 	{
-		
+    {
+      std::stringstream tmp;
+      tmp << other.name << "_copy";
+      name = tmp.str();
+    }
 		m_link = this;
 		integer selfid = TieElement(5);
 		assert(selfid == 0);
@@ -309,11 +341,17 @@ namespace INMOST
 		//this is not needed as it was copied with all the other data
 		//recompute global ids
 		//AssignGlobalID(other.have_global_id);
+    allocated_meshes.push_back(this);
 	}
 	
 	Mesh & Mesh::operator =(Mesh const & other)
 	{
 		if( this == &other ) return *this; //don't do anything
+    {
+      std::stringstream tmp;
+      tmp << other.name << "_copy";
+      name = tmp.str();
+    }
 		//first delete everything
 		//delete parallel vars
 #if defined(USE_MPI)
@@ -526,11 +564,14 @@ namespace INMOST
 #endif //USE_MPI
 #if defined(USE_PARALLEL_WRITE_TIME)
 		FinalizeFile();
-		
-		for(size_t q = 0; q < allocated_meshes.size(); ++q)
-			if (allocated_meshes[q] == this)
-				allocated_meshes[q] = NULL;
 #endif //USE_PARALLEL_WRITE_TIME
+    {
+      for(size_t q = 0; q < allocated_meshes.size(); ++q)
+			  if (allocated_meshes[q] == this)
+				  allocated_meshes[q] = NULL;
+      std::sort(allocated_meshes.rbegin(), allocated_meshes.rend());
+      while(allocated_meshes.back() == NULL) allocated_meshes.pop_back();
+    }
 		//arrays for data are deallocated inside ~TagManager()
 	}
 	
@@ -1882,6 +1923,15 @@ namespace INMOST
 		else 
 			return static_cast<inner_reference_array*>(p)->at_safe(0);
 	}
+  Storage::remote_reference & Mesh::RemoteReference(HandleType h, const Tag & tag) 
+	{
+		Asserts(h,tag,DATA_REMOTE_REFERENCE);
+		void * p = MGetLink(h,tag); 
+		if( tag.GetSize() != ENUMUNDEF ) 
+			return static_cast<remote_reference*>(p)[0]; 
+		else 
+			return static_cast<inner_remote_reference_array*>(p)->at_safe(0);
+	}
 	Storage::real_array Mesh::RealArray(HandleType h, const Tag & tag) 
 	{
 		Asserts(h,tag,DATA_REAL);
@@ -1908,7 +1958,8 @@ namespace INMOST
 		if( tag.GetSize() == ENUMUNDEF ) 
 			return bulk_array(*static_cast<inner_bulk_array     *>(p)); 
 		else 
-			return bulk_array(static_cast<bulk*>(p),tag.GetSize());}
+			return bulk_array(static_cast<bulk*>(p),tag.GetSize());
+  }
 	Storage::reference_array Mesh::ReferenceArray(HandleType h, const Tag & tag) 
 	{
 		Asserts(h,tag,DATA_REFERENCE);
@@ -1918,6 +1969,15 @@ namespace INMOST
 		else 
 			return reference_array(this,static_cast<reference *>(p),tag.GetSize());
 	}
+  Storage::remote_reference_array Mesh::RemoteReferenceArray(HandleType h, const Tag & tag) 
+	{
+		Asserts(h,tag,DATA_REMOTE_REFERENCE);
+		void * p = MGetLink(h,tag); 
+		if( tag.GetSize() == ENUMUNDEF ) 
+			return remote_reference_array(*static_cast<inner_remote_reference_array*>(p)); 
+		else 
+			return remote_reference_array(static_cast<remote_reference *>(p),tag.GetSize());
+	}
 	
 	void Mesh::AssertsDV(HandleType h, const Tag & tag, DataType expected) const
 	{
@@ -1972,6 +2032,8 @@ namespace INMOST
 				case DATA_INTEGER:  return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_integer_array  *>(adata)->size());
 				case DATA_BULK:     return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_bulk_array     *>(adata)->size());
 				case DATA_REFERENCE:return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_reference_array*>(adata)->size());
+        case DATA_REMOTE_REFERENCE:
+                            return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_remote_reference_array*>(adata)->size());
 #if defined(USE_AUTODIFF)
         case DATA_VARIABLE: return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_variable_array *>(adata)->size());
 #endif
@@ -1993,6 +2055,8 @@ namespace INMOST
 				case DATA_INTEGER:  return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_integer_array  *>(adata)->size())*tag.GetBytesSize();
 				case DATA_BULK:     return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_bulk_array     *>(adata)->size())*tag.GetBytesSize();
 				case DATA_REFERENCE:return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_reference_array*>(adata)->size())*tag.GetBytesSize();
+        case DATA_REMOTE_REFERENCE:
+                            return static_cast<INMOST_DATA_ENUM_TYPE>(static_cast<const inner_remote_reference_array*>(adata)->size())*tag.GetBytesSize();
 #if defined(USE_AUTODIFF)
         case DATA_VARIABLE: 
           {
@@ -2030,6 +2094,8 @@ namespace INMOST
 				case DATA_INTEGER:  static_cast<inner_integer_array   *>(adata)->resize(new_size); break;
 				case DATA_BULK:     static_cast<inner_bulk_array      *>(adata)->resize(new_size); break;
 				case DATA_REFERENCE:static_cast<inner_reference_array *>(adata)->resize(new_size); break;
+        case DATA_REMOTE_REFERENCE:
+                            static_cast<inner_remote_reference_array *>(adata)->resize(new_size); break;
 #if defined(USE_AUTODIFF)
         case DATA_VARIABLE: static_cast<inner_variable_array  *>(adata)->resize(new_size); break;
 #endif
@@ -2055,6 +2121,8 @@ namespace INMOST
 				case DATA_INTEGER:  memcpy(data_out,&(*static_cast<const inner_integer_array   *>(adata))[shift],bytes*size); break;
 				case DATA_BULK:     memcpy(data_out,&(*static_cast<const inner_bulk_array      *>(adata))[shift],bytes*size); break;
 				case DATA_REFERENCE:memcpy(data_out,&(*static_cast<const inner_reference_array *>(adata))[shift],bytes*size); break;
+        case DATA_REMOTE_REFERENCE:
+                            memcpy(data_out,&(*static_cast<const inner_remote_reference_array *>(adata))[shift],bytes*size); break;
 #if defined(USE_AUTODIFF)
         case DATA_VARIABLE:
           {
@@ -2118,6 +2186,8 @@ namespace INMOST
 				case DATA_INTEGER:  memcpy(&(*static_cast<inner_integer_array  *>(adata))[shift],data_in,bytes*size); break;
 				case DATA_BULK:     memcpy(&(*static_cast<inner_bulk_array     *>(adata))[shift],data_in,bytes*size); break;
 				case DATA_REFERENCE:memcpy(&(*static_cast<inner_reference_array*>(adata))[shift],data_in,bytes*size); break;
+        case DATA_REMOTE_REFERENCE:
+                            memcpy(&(*static_cast<inner_reference_array*>(adata))[shift],data_in,bytes*size); break;
 #if defined(USE_AUTODIFF)
         case DATA_VARIABLE:
           {

Source/Mesh/parallel.cpp

@@ -2082,7 +2082,7 @@ namespace INMOST
 	
 	void Mesh::PackTagData(const Tag & tag, const elements_by_type & elements, ElementType mask, MarkerType select, buffer_type & buffer)
 	{
-		if( tag.GetDataType() == DATA_REFERENCE ) return; //NOT IMPLEMENTED TODO 14
+    if( tag.GetDataType() == DATA_REFERENCE || tag.GetDataType() == DATA_REMOTE_REFERENCE ) return; //NOT IMPLEMENTED TODO 14
 		ENTER_FUNC();
 #if defined(USE_MPI)
 		ElementType pack_types[2] = {NONE,NONE};
@@ -2168,7 +2168,7 @@ namespace INMOST
 	void Mesh::UnpackTagData(const Tag & tag, const elements_by_type & elements, ElementType mask, MarkerType select, buffer_type & buffer, int & position, ReduceOperation op)
 	{
 		(void) mask;
-		if( tag.GetDataType() == DATA_REFERENCE ) return; //NOT IMPLEMENTED TODO 14
+		if( tag.GetDataType() == DATA_REFERENCE || tag.GetDataType() == DATA_REMOTE_REFERENCE) return; //NOT IMPLEMENTED TODO 14
 		ENTER_FUNC();
 		REPORT_VAL("TagName",tag.GetTagName());