fix omission in generic ID functions and add unit test

while in debugging, it turned out that the short type-prefix
was implemented in a too simplistic way; it fails on stuff
like 'lib::diff::Record<lib::diff::GenNode>'


while I must add, that the whole purpose of these ID functions
is somewhat unclear and needs to reveal itself as we move forward

src/lib/idi/genfunc.cpp

@@ -48,9 +48,11 @@ namespace idi {
     demangled_innermost_component (const char* rawName)
     {
       string typeStr = demangleCxx (rawName);
-      size_t pos = typeStr.rfind("::");
+      size_t end = typeStr.rfind("<");
+      size_t pos = typeStr.rfind("::", end);
       if (pos != string::npos)
-        typeStr = typeStr.substr(pos+2);
+        typeStr = (end==string::npos? typeStr.substr(pos+2)
+                                    : typeStr.substr(pos+2, end-pos-2));
       return typeStr;
     }
     

src/lib/idi/genfunc.hpp

@@ -33,6 +33,9 @@
  ** - render an ID in human readable form
  ** - derive a hash function
  ** 
+ ** @todo better unit test coverage
+ ** @todo improve implementation of typeFullID
+ ** @see GenericIdFunction_test
  ** @see EntryID
  **
  */
@@ -105,7 +108,7 @@ namespace idi {
   }
   
   
-  /** build a per-type unique identifier.
+  /** build a per-type identifier, with type prefix and running counter.
    * @return a type based prefix, followed by an instance number
    * @note we use the short prefix without namespace, not necessarily unique
    * @todo consequently the generated IDs might clash for two distinct types,

tests/15library.tests

@@ -209,6 +209,11 @@ return: 0
 END
 
 
+TEST "Generic ID generation" GenericIdFunction_test <<END
+return: 0
+END
+
+
 PLANNED "GenNodeBasic_test" GenNodeBasic_test <<END
 return: 0
 END

tests/library/idi/generic-id-function-test.cpp

@@ -0,0 +1,143 @@
+/*
+  GenericIdFunction(Test)  -  cover instance and type id generation
+
+  Copyright (C)         Lumiera.org
+    2015,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+* *****************************************************/
+
+
+#include "lib/test/run.hpp"
+//#include "lib/test/test-helper.hpp"
+#include "lib/idi/genfunc.hpp"
+
+//#include <utility>
+//#include <string>
+//#include <vector>
+#include <iostream>
+
+//using std::string;
+//using std::vector;
+using std::cout;
+using std::endl;
+//using std::swap;
+
+
+namespace lib {
+namespace idi {
+namespace test{
+  
+//  using lumiera::error::LUMIERA_ERROR_LOGIC;
+  
+  namespace {//Test fixture....
+    
+    class Thing
+      { };
+    
+    template<typename X>
+    struct Some
+      {
+        X x;
+      };
+    
+    typedef Some<Thing> SomeThing;
+    
+  }//(End)Test fixture
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  /**************************************************************************//**
+   * @test cover a standard scheme to generate type and instance identifiers.
+   *       
+   * @see EntryID
+   * @see StructFactory
+   */
+  class GenericIdFunction_test : public Test
+    {
+      
+      virtual void
+      run (Arg)
+        {
+          simpleUsage();
+          verify_typeSymbol();
+          verify_fullTypeID();
+          verify_prefix();
+          verify_typeHash();
+          verify_symbolicInstanceID();
+        }
+      
+      
+      void
+      simpleUsage()
+        {
+          CHECK ("int" == typeSymbol<int>());
+          CHECK ("bool" == typeSymbol<bool>());
+          
+          CHECK ("Some" == categoryFolder<SomeThing>());
+        }
+      
+      
+      void
+      verify_typeSymbol()
+        {
+        }
+      
+      
+      void
+      verify_fullTypeID()
+        {
+          //////TODO this should be a identifier with only letters, numbers and underscores. Need to extend the util::sanitise
+          CHECK("lib::idi::test::(anonymous_namespace)::Somelib::idi::test::(anonymous_namespace)::Thing" == typeFullID<SomeThing>());
+        }
+      
+      
+      void
+      verify_prefix()
+        {
+        }
+      
+      
+      void
+      verify_typeHash()
+        {
+        }
+      
+      
+      void
+      verify_symbolicInstanceID()
+        {
+          class Unique { };
+          
+          CHECK ("Unique.001" == generateSymbolicID<Unique>());
+          CHECK ("Unique.002" == generateSymbolicID<Unique>());
+          CHECK ("Unique.003" == generateSymbolicID<Unique>());
+        }
+    };
+  
+  
+  /** Register this test class... */
+  LAUNCHER (GenericIdFunction_test, "unit common");
+  
+  
+  
+}}} // namespace lib::idi::test