C++ util::isnil方法代码示例

 void
 produce_simple_values()
   {
     using TestFactory = factory::MultiFact<string, theID>;
     
     TestFactory theFact;
     
     // the first "production line" is wired to a free function
     theFact.defineProduction (ONE, buildOne);
     
     // second "production line" uses a explicit partial closure
     theFact.defineProduction (TWO, bind (buildSome<theID>, TWO));
     
     // for the third "production line" we set up a function object
     auto memberFunction = bind (&MultiFact_test::callMe, this, "lalü");
     theFact.defineProduction (THR, memberFunction);
     
     // and the fourth "production line" uses a lambda, closed with a local reference
     string backdoor("backdoor");
     theFact.defineProduction (FOU, [&] {
                                       return backdoor;
                                    });
     
     CHECK (!isnil (theFact));
     CHECK (theFact(ONE) == "1");
     CHECK (theFact(TWO) == "2");
     
     CHECK (theFact(THR) == "lalü");
     CHECK (invocations_ == 1);
     
     CHECK (theFact(FOU) == "backdoor");
     backdoor = "I am " + backdoor.substr(0,4);
     CHECK (theFact(FOU) == "I am back");
     
     
     TestFactory anotherFact;
     CHECK (isnil (anotherFact));
     VERIFY_ERROR (INVALID, anotherFact(ONE) );
     
     anotherFact.defineProduction (ONE, memberFunction);
     CHECK (anotherFact(ONE) == "lalü");
     CHECK (invocations_ == 2);
     
     CHECK (theFact(THR) == "lalü");
     CHECK (invocations_ == 3);
     
     
     CHECK ( theFact.contains (FOU));
     CHECK (!anotherFact.contains (FOU));
     
     anotherFact = theFact;
     CHECK (anotherFact.contains (FOU));
     CHECK (!isSameObject(theFact, anotherFact));
     
     CHECK (anotherFact(ONE) == "1");
     CHECK (anotherFact(TWO) == "2");
     CHECK (anotherFact(THR) == "lalü");
     CHECK (anotherFact(FOU) == "I am back");
     CHECK (invocations_ == 4);
   }

 const Asset::Ident
 createIdent (Query<STRU> const& query)
   {
     // does the query somehow specify the desired name-ID?
     string nameID = query.extractID (genericIdSymbol);
     if (isnil (nameID))
       nameID = query.extractID (StructTraits<STRU>::idSymbol());
     if (isnil (nameID))
       {
          // no name-ID contained in the query...
         //  so we'll create a new one
         static int i=0;
         nameID = _Fmt("%s.%d")
                      % StructTraits<STRU>::namePrefix()
                      % (++i);
       }
     ENSURE (!isnil (nameID));
     
     // does the query actually demand the Nth instance/element?
     string seqID = query.extractID (seqNrPredicate);
     if (!isnil (seqID) && 1 < uNum(seqID))
       nameID += "."+seqID;
     
     Category cat (STRUCT, StructTraits<STRU>::catFolder());
     return Asset::Ident (nameID, cat );
   }

 void
 sigTerm (Subsys* susy, string* problem) ///< called from subsystem on termination
   {
     REQUIRE (susy);
     Lock sync (this);
     triggerEmergency(!isnil (problem));
     INFO (subsystem, "Subsystem '%s' terminated.", cStr(*susy));
     WARN_IF (!isnil(problem), subsystem, "Irregular shutdown caused by: %s", cStr(*problem));
     ERROR_IF (susy->isRunning(), subsystem, "Subsystem '%s' signals termination, "
                                             "without resetting running state", cStr(*susy));
     removeall (running_, susy);
     shutdownAll();
     sync.notify();
   }

 virtual void
 run (Arg)
   {
     IterQueue<int> queue;
     CHECK (isnil (queue));
     
     VERIFY_ERROR (ITER_EXHAUST,  *queue );
     VERIFY_ERROR (ITER_EXHAUST, ++queue );
     
     queue.feed (1);
     queue.feed (3);
     queue.feed (5);
     
     CHECK (!isnil (queue));
     CHECK (1 == *queue);
     
     ++queue;
     CHECK (3 == *queue);
     
     CHECK (3 == queue.pop());
     CHECK (5 == *queue);
     
     ++queue;
     CHECK (isnil (queue));
     VERIFY_ERROR (ITER_EXHAUST,  *queue );
     VERIFY_ERROR (ITER_EXHAUST, ++queue );
     VERIFY_ERROR (ITER_EXHAUST, queue.pop() );
     
     
     // use the generic builder API to feed
     // the contents of another iterator into the queue
     queue = build(queue).usingSequence (elements (23,45));
     
     int i = queue.pop();
     CHECK (i == 23);
     CHECK (45 == *queue);
     
     // feeding new elements and pulling / iteration can be mixed
     queue.feed(67);
     CHECK (45 == *queue);
     ++queue;
     CHECK (67 == *queue);
     ++queue;
     CHECK (isnil (queue));
     queue.feed(89);
     CHECK (89 == *queue);
     queue.pop();
     VERIFY_ERROR (ITER_EXHAUST,  *queue );
   }

      /** @test OpaqueHolder with additional storage for subclass.
       *        When a subclass requires more storage than the base class or
       *        Interface, we need to create a custom OpaqueHolder, specifying the
       *        actually necessary storage. Such a custom OpaqueHolder behaves exactly
       *        like the standard variant, but there is protection against accidentally
       *        using a standard variant to hold an instance of the larger subclass.
       *        
       *  @test Moreover, if the concrete class has a custom operator bool(), it
       *        will be invoked automatically from OpaqueHolder's operator bool()
       * 
       */ 
      void
      checkSpecialSubclass ()
        {
          typedef OpaqueHolder<Base, sizeof(Special)> SpecialOpaque;
          
          cout << showSizeof<Base>() << endl;
          cout << showSizeof<Special>() << endl;
          cout << showSizeof<Opaque>() << endl;
          cout << showSizeof<SpecialOpaque>() << endl;
          
          CHECK (sizeof(Special) > sizeof(Base));
          CHECK (sizeof(SpecialOpaque) > sizeof(Opaque));
          CHECK (sizeof(SpecialOpaque) <= sizeof(Special) + sizeof(void*) + _ALIGN_);
          
          Special s1 (6);
          Special s2 (3);
          CHECK (!s1);               // even value
          CHECK (s2);                // odd value
          CHECK (7 == s1.getIt());   // indeed subclass of DD<7>
          CHECK (7 == s2.getIt());
          
          SpecialOpaque ospe0;
          SpecialOpaque ospe1 (s1);
          SpecialOpaque ospe2 (s2);
          
          CHECK (!ospe0);            // note: bool test (isValid)
          CHECK (!ospe1);            // also forwarded to contained object (myVal_==6 is even)
          CHECK ( ospe2);
          CHECK ( isnil(ospe0));     // while isnil just checks the empty state
          CHECK (!isnil(ospe1));
          CHECK (!isnil(ospe2));
          
          CHECK (7 == ospe1->getIt());
          CHECK (6 == ospe1.get<Special>().myVal_);
          CHECK (3 == ospe2.get<Special>().myVal_);
          
          ospe1 = DD<5>();            // but can be reassigned like any normal Opaque
          CHECK (ospe1);
          CHECK (5 == ospe1->getIt());
          VERIFY_ERROR (WRONG_TYPE, ospe1.get<Special>() );
          
          Opaque normal = DD<5>();
          CHECK (normal);
          CHECK (5 == normal->getIt());
#if false ////////////////////////////////////////////////////////TODO: restore throwing ASSERT
          // Assertion protects against SEGV
          VERIFY_ERROR (ASSERTION, normal = s1 );
#endif////////////////////////////////////////////////////////////
        }

 void
 checkSTLContainer()
   {
     typedef std::map<int,HO> MapHO;
     
     CHECK (0 == Dummy::checksum());
     {
       MapHO maph;
       CHECK (isnil (maph));
       
       for (uint i=0; i<100; ++i)
         {
           HO & contained = maph[i];
           CHECK (!contained);
         }                      // 100 holder objects created by sideeffect
                               // ..... without creating any contained object!  
       CHECK (0 == Dummy::checksum());
       CHECK (!isnil (maph));
       CHECK (100==maph.size());
       
       for (uint i=0; i<100; ++i)
         {
           create_contained_object (maph[i]);
           CHECK (maph[i]);
           CHECK (0 < maph[i]->acc(12));
         }
       CHECK (100==maph.size());
       CHECK (0 != Dummy::checksum());
       
       
       long value55 = maph[55]->acc(0); 
       long currSum = Dummy::checksum();
       
       CHECK (1 == maph.erase(55));
       CHECK (Dummy::checksum() == currSum - value55); // proves object#55's dtor has been invoked
       CHECK (maph.size() == 99);
       
       maph[55];                              // create new empty holder by sideeffect...
       CHECK (&maph[55]);
       CHECK (!maph[55]);
       CHECK (maph.size() == 100);
     }
     CHECK (0 == Dummy::checksum());
   }

    void
    verify_transformIter()
    {
        WrappedList customList(NUM_ELMS);
        WrappedList::iterator sourceValues = customList.begin();

        TimeIter tIt (transform (sourceValues, makeTime));
        CHECK (!isnil (tIt));
        pullOut (tIt);
        CHECK (!tIt);
    }

 inline Pipe* 
 StructFactoryImpl::fabricate (Query<Pipe> const& caps)
 {
   const Asset::Ident idi (createIdent (caps));
   string streamID = caps.extractID ("stream");
   if (isnil (streamID)) streamID = "default"; 
   PProcPatt processingPattern = Session::current->defaults (Query<const ProcPatt>("stream("+streamID+")"));
   return new Pipe( idi
                  , streamID
                  , processingPattern
                  );                             ///////////////////////TICKET #565  maybe store the capabilities query within the Struct asset somehow?
 }

 inline Timeline* 
 StructFactoryImpl::fabricate (Query<Timeline> const& caps)
 {
   TODO ("extract additional properties/capabilities from the query...");
   const Asset::Ident idi (createIdent (caps));
   string sequenceID = caps.extractID ("sequence");
   Query<Sequence> desiredSequence (isnil (sequenceID)? "" : "id("+sequenceID+")");
   PSequence sequence = recursive_create_(desiredSequence);
   ASSERT (sequence);
   RBinding newBinding = Session::current->getRoot().attach (MObject::create (sequence));
   ASSERT (newBinding);
   PTimeline newTimeline = Timeline::create (idi, newBinding);
   ENSURE (newTimeline);                         ///////////////////////TICKET #565  maybe store the capabilities query within the Struct asset somehow?
   return newTimeline.get();
 }

 /** either fetch or build a suitable fork root for a new sequence */
 RFork
 getFork_forSequence (string const& desiredID)
   {
     RFork fork;
     if (!isnil (desiredID))
       fork = Session::current->elements.pick (match_specificFork (desiredID));
     
     if (fork && !Scope::containing (fork.getRef()).isRoot())
       {
         UNIMPLEMENTED ("how to deal with 'stealing' a fork sub-tree to a new sequence??");
       }
     if (!fork)
       fork = Session::current->getRoot().attach (MObject::create (ForkID (desiredID)));
     
     return fork;
   }

 void
 produce_smart_pointers()
   {
     using TestFactory = factory::MultiFact<Interface, theID, factory::BuildRefcountPtr>;
     using PIfa = shared_ptr<Interface>;
     
     TestFactory theFact;
     
     // set up the "production lines" by lambda
     theFact.defineProduction (ONE, [] { return new Implementation<ONE>; });
     theFact.defineProduction (TWO, [] { return new Implementation<TWO>; });
     theFact.defineProduction (THR, [] { return new Implementation<THR>; });
     theFact.defineProduction (FOU, [] { return new Implementation<FOU>; });
     CHECK (!isnil (theFact));
     
     PIfa p1 = theFact(ONE);
     PIfa p2 = theFact(TWO);
     PIfa p3 = theFact(THR);
     PIfa p4 = theFact(FOU);
     
     PIfa p11 = theFact(ONE);
     
     CHECK ("Impl-1" == string(*p1));
     CHECK ("Impl-2" == string(*p2));
     CHECK ("Impl-3" == string(*p3));
     CHECK ("Impl-4" == string(*p4));
     
     CHECK ("Impl-1" == string(*p11));
     CHECK (!isSameObject(*p1, *p11));
     
     PIfa p12(p11);
     CHECK (isSameObject(*p11, *p12));
     CHECK ("Impl-1" == string(*p12));
     CHECK (1 == p1.use_count());
     CHECK (2 == p11.use_count());
     CHECK (2 == p12.use_count());
   }

 bool
 isValid()  const
   {
     return isnil (failureLog_);
   }

      /** @test cover the basic situations of object handling,
       *        especially copy operations and re-assignments
       */
      void
      checkHandling (TestList& objs)
        {
          Opaque oo;
          CHECK (!oo);
          CHECK (isnil(oo));
          
          oo = objs[1];
          CHECK (oo);
          CHECK (!isnil(oo));
          
          typedef DD<3> D3;
          typedef DD<5> D5;
          D3 d3 (oo.get<D3>() );
          CHECK (3 == oo->getIt());    // re-access through Base interface
          CHECK (!isSameObject (d3, *oo));
          VERIFY_ERROR (WRONG_TYPE, oo.get<D5>() );
          
          // direct assignment of target into Buffer
          oo = D5();
          CHECK (oo);
          CHECK (5 == oo->getIt());
          VERIFY_ERROR (WRONG_TYPE, oo.get<D3>() );
          
          // can get a direct reference to contained object
          D5 &rd5 (oo.get<D5>()); 
          CHECK (isSameObject (rd5, *oo));
          
          CHECK (!isnil(oo));
          oo = objs[3];     // copy construction also works on non-empty object
          CHECK (7 == oo->getIt());
          
          // WARNING: direct ref has been messed up through the backdoor!
          CHECK (7 == rd5.getIt());
          CHECK (isSameObject (rd5, *oo));
          
          uint cnt_before = _create_count;
          
          oo.clear();
          CHECK (!oo);
          oo = D5();        // direct assignment also works on empty object
          CHECK (oo);
          CHECK (5 == oo->getIt());
          CHECK (_create_count == 2 + cnt_before);
          // one within buff and one for the anonymous temporary D5()
          
          
          // verify that self-assignment is properly detected...
          cnt_before = _create_count;
          oo = oo;
          CHECK (oo);
          CHECK (_create_count == cnt_before);
          oo = oo.get<D5>();
          CHECK (_create_count == cnt_before);
          oo = *oo;
          CHECK (_create_count == cnt_before);
          CHECK (oo);
          
          oo.clear();
          CHECK (!oo);
          CHECK (isnil(oo));
          VERIFY_ERROR (BOTTOM_VALUE, oo.get<D5>() );
#if false ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
          VERIFY_ERROR (ASSERTION, oo->getIt() );
#endif    ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
          // can't access empty holder...
          
          Opaque o1 (oo);
          CHECK (!o1);
          
          Opaque o2 (d3);
          CHECK (!isSameObject (d3, *o2));
          CHECK (3 == o2->getIt());
          
          CHECK (sizeof(Opaque) <= sizeof(Base) + sizeof(void*) + _ALIGN_);
        }