not-yet-implemented....

src/proc/mobject/session/placement-index.cpp

@@ -534,6 +534,7 @@ namespace session {
   
   /* ====== PlacementIndex validity self-check ====== */
   
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 479  !!!!!!!!!
   namespace { // Implementation details of self-check
     
     LUMIERA_ERROR_DEFINE(INDEX_CORRUPTED, "PlacementIndex corrupted");
@@ -621,6 +622,7 @@ namespace session {
 #undef SCO
     
   }//(End) self-check implementation
+#endif ////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
   
   
   
@@ -636,6 +638,7 @@ namespace session {
   bool
   PlacementIndex::isValid()  const
   {
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 479  !!!!!!!!!
     try
       {
         if (!pTab_)
@@ -656,6 +659,7 @@ namespace session {
         lumiera_error();
         ERROR (session, "%s", failure.what());
       }
+#endif ////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
     return false;
   }
   

tests/lib/util-foreach-test.cpp

@@ -133,21 +133,21 @@ namespace test {
           RangeI iterator(container.begin(), container.end());
           
           check_foreach_plain (container);
-          check_foreach_plain (iterator);
+//        check_foreach_plain (iterator);
           
           check_foreach_bind (container);
-          check_foreach_bind (iterator);
+//        check_foreach_bind (iterator);
           
           check_foreach_memFun (container);
-          check_foreach_memFun (iterator);
+//        check_foreach_memFun (iterator);
           
           check_foreach_lambda (container);
-          check_foreach_lambda (iterator);
+//        check_foreach_lambda (iterator);
           
           check_existence_quant (container);
-          check_existence_quant (iterator);
+//        check_existence_quant (iterator);
           
-          check_invoke_on_each (iterator);
+          check_invoke_on_each ();
         }
       
       
@@ -185,6 +185,7 @@ namespace test {
           function<bool(int,int)>     fun1(function1);
           function<bool(int,int,int)> fun2(function2);
           
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 479  !!!!!!!!!
           for_each (coll, function1, 10, _1 );               _NL_
           for_each (coll, &function1,10, _1 );               _NL_
           for_each (coll, fun1,      10, _1 );               _NL_
@@ -241,6 +242,7 @@ namespace test {
           has_any (coll, &function2, _1, _1, ref(sum) );     _NL_
           has_any (coll, fun2,       _1, _1, ref(sum) );     _NL_
           
+#endif ////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
         }
       
       
@@ -264,6 +266,7 @@ namespace test {
         {
           Dummy dummy;
           
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 479  !!!!!!!!!
           for_each (coll, &Dummy::fun, dummy,  _1 );      _NL_
           and_all  (coll, &Dummy::fun, dummy,  _1 );      _NL_
           has_any  (coll, &Dummy::fun, dummy,  _1 );      _NL_
@@ -271,7 +274,7 @@ namespace test {
           for_each (coll, &Dummy::fun, &dummy, _1 );     _NL_
           and_all  (coll, &Dummy::fun, &dummy, _1 );     _NL_
           has_any  (coll, &Dummy::fun, &dummy, _1 );     _NL_
-          
+#endif ////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
           
         }
       
@@ -318,19 +321,19 @@ namespace test {
       /** @test the binding can also be used to \em dispatch an operation
        *        on each element within a object collection: here the parameter
        *        is used as \c this pointer to specify the object instance */
-      template<typename CO>
       void
-      check_invoke_on_each (CO coll)
+      check_invoke_on_each ()
         {
-          vector<TestElm> elms;
+          std::vector<TestElm> elms;
           for (uint i=0; i<6; ++i)
             elms.push_back (TestElm(i));
           
-          vector<TestElm*> elmPtrs;
+          std::vector<TestElm*> elmPtrs;
           for (uint i=0; i<6; ++i)
-            elms.push_back (& elms[i]);
+            elmPtrs.push_back (& elms[i]);
           
           // fed the element pointer as "this" pointer of the member function
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 479  !!!!!!!!!
           for_each (elmPtrs, &TestElm::operation, _1 );      _NL_
           and_all  (elmPtrs, &TestElm::operation, _1 );      _NL_
           has_any  (elmPtrs, &TestElm::operation, _1 );      _NL_
@@ -339,6 +342,7 @@ namespace test {
           for_each (elms, &TestElm::operation, _1 );         _NL_
           and_all  (elms, &TestElm::operation, _1 );         _NL_
           has_any  (elms, &TestElm::operation, _1 );         _NL_
+#endif ////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
         }
     };