Feature

Added some doxygen comments into inmost_dense.h

Added comments to Element::Boundary

Handy replacement for Tag class that provide data access through square
brackets.

Source/Headers/inmost_data.h

@@ -220,8 +220,10 @@ namespace INMOST
 		friend class Storage;
 		friend class Mesh;
 	};
+	
+	
 
-  class TagManager //implemented in tag.cpp
+	class TagManager //implemented in tag.cpp
 	{
 	protected:
 		TagManager();
@@ -607,6 +609,120 @@ namespace INMOST
 		__INLINE ElementSet                 getAsSet            () const;
 		friend class Mesh;
 	};
+	
+	//////////////////////////////////////////////////////////////////////
+	/// Helper classes for class Tag                                    //
+	//////////////////////////////////////////////////////////////////////
+	
+	class TagReal : public Tag
+	{
+	public:
+		TagReal() : Tag() {}
+		TagReal(const TagReal & b) : Tag(b) {}
+		TagReal(const Tag & b) : Tag(b) {}
+		TagReal & operator = (TagReal const & b) {Tag::operator =(b); return *this;}
+		TagReal & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::real & operator [](const Storage & arg) const {return arg.Real(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagInteger : public Tag
+	{
+	public:
+		TagInteger() : Tag() {}
+		TagInteger(const TagInteger & b) : Tag(b) {}
+		TagInteger(const Tag & b) : Tag(b) {}
+		TagInteger & operator = (TagInteger const & b) {Tag::operator =(b); return *this;}
+		TagInteger & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::integer & operator [](const Storage & arg) const {return arg.Integer(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagBulk : public Tag
+	{
+	public:
+		TagBulk() : Tag() {}
+		TagBulk(const TagBulk & b) : Tag(b) {}
+		TagBulk(const Tag & b) : Tag(b) {}
+		TagBulk & operator = (TagBulk const & b) {Tag::operator =(b); return *this;}
+		TagBulk & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::bulk & operator [](const Storage & arg) const {return arg.Bulk(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagReference : public Tag
+	{
+	public:
+		TagReference() : Tag() {}
+		TagReference(const TagReference & b) : Tag(b) {}
+		TagReference(const Tag & b) : Tag(b) {}
+		TagReference & operator = (TagReference const & b) {Tag::operator =(b); return *this;}
+		TagReference & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::reference & operator [](const Storage & arg) const {return arg.Reference(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagVariable : public Tag
+	{
+	public:
+		TagVariable() : Tag() {}
+		TagVariable(const TagVariable & b) : Tag(b) {}
+		TagVariable(const Tag & b) : Tag(b) {}
+		TagVariable & operator = (TagVariable const & b) {Tag::operator =(b); return *this;}
+		TagVariable & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::var & operator [](const Storage & arg) const {return arg.Variable(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagRealArray : public Tag
+	{
+	public:
+		TagRealArray() : Tag() {}
+		TagRealArray(const TagRealArray & b) : Tag(b) {}
+		TagRealArray(const Tag & b) : Tag(b) {}
+		TagRealArray & operator = (TagRealArray const & b) {Tag::operator =(b); return *this;}
+		TagRealArray & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::real_array operator [](const Storage & arg) const {return arg.RealArray(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagIntegerArray : public Tag
+	{
+	public:
+		TagIntegerArray() : Tag() {}
+		TagIntegerArray(const TagIntegerArray & b) : Tag(b) {}
+		TagIntegerArray(const Tag & b) : Tag(b) {}
+		TagIntegerArray & operator = (TagIntegerArray const & b) {Tag::operator =(b); return *this;}
+		TagIntegerArray & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::integer_array operator [](const Storage & arg) const {return arg.IntegerArray(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagBulkArray : public Tag
+	{
+	public:
+		TagBulkArray() : Tag() {}
+		TagBulkArray(const TagBulkArray & b) : Tag(b) {}
+		TagBulkArray(const Tag & b) : Tag(b) {}
+		TagBulkArray & operator = (TagBulkArray const & b) {Tag::operator =(b); return *this;}
+		TagBulkArray & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::bulk_array operator [](const Storage & arg) const {return arg.BulkArray(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagReferenceArray : public Tag
+	{
+	public:
+		TagReferenceArray() : Tag() {}
+		TagReferenceArray(const TagReferenceArray & b) : Tag(b) {}
+		TagReferenceArray(const Tag & b) : Tag(b) {}
+		TagReferenceArray & operator = (TagReferenceArray const & b) {Tag::operator =(b); return *this;}
+		TagReferenceArray & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::reference_array operator [](const Storage & arg) const {return arg.ReferenceArray(*static_cast<const Tag*>(this));}
+	};
+	
+	class TagVariableArray : public Tag
+	{
+	public:
+		TagVariableArray() : Tag() {}
+		TagVariableArray(const TagVariableArray & b) : Tag(b) {}
+		TagVariableArray(const Tag & b) : Tag(b) {}
+		TagVariableArray & operator = (TagVariableArray const & b) {Tag::operator =(b); return *this;}
+		TagVariableArray & operator = (Tag const & b) {Tag::operator =(b); return *this;}
+		Storage::var_array operator [](const Storage & arg) const {return arg.VariableArray(*static_cast<const Tag*>(this));}
+	};
 
 	//////////////////////////////////////////////////////////////////////
 	/// Inline functions for class Tag                                  //

Source/Headers/inmost_mesh.h

@@ -438,18 +438,28 @@ namespace INMOST
 		void                        Centroid                (real * cnt) const;
 		void                        Barycenter              (real * cnt) const;
 		Storage::real               Mean                    (real (*func)(real* x,real t),real time) const;
+		/// Determine that the element is on the boundary.
+		/// \warning This function does not involve communication
+		/// for distributed mesh and works only for local partition
+		/// of the mesh. It cannot correctly determine boundary elements
+		/// of the global mesh. For this purpose you should use
+		/// Mesh::MarkBoundaryFaces
+		/// @return True if the element is on the boundary, otherwise false.
+		/// @see Mesh::MarkBoundaryFaces
 		bool                        Boundary                () const;
 		bool                        Planarity               () const; // check that all nodes lay on one plane
 		//implemented in modify.cpp
 		/// If the function returns true then element was hidden,
 		/// works only inside BeginModification and EndModification,
 		/// on EndModification all Hidden elements are deleted.
-		/// \todo Probably have to check normal orientation after hiding a back cell for a face.
+		/// \todo Probably have to check normal orientation after
+		/// hiding a back cell for a face.
 		bool                        Hide                    () const;
 		/// If the function returns true then element was recovered
 		/// from hidden state, works only inside BeginModification
 		/// and EndModification.
-		/// \todo Probably have to check normal orientation after recovering a back cell for a face.
+		/// \todo Probably have to check normal orientation after
+		/// recovering a back cell for a face.
 		bool                        Show                    () const; // if true then element was recovered
 		/// Remove element from mesh.
 		/// If you call this function inside modification phase, see Mesh::BeginModification and Mesh::EndModification,

Source/Mesh/geometry.cpp

@@ -1134,11 +1134,8 @@ namespace INMOST
 		switch(GetElementType())
 		{
 			case FACE:
-				if( nbAdjElements(CELL) == 1 )
-				{
-					if( getAsFace()->BackCell()->GetStatus() != Element::Ghost )
-						return true;
-				}
+				if( !getAsFace()->FrontCell().isValid() )
+					return true;
 				return false;
 			case CELL:
 			case EDGE: