C / C++ / MFC

Arnon A wrote:

cou<<valuedata;< blockquote="">

Shouldn't this be wcout?

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"Man who follows car will be exhausted." - Confucius

#include 


class Cloneable
{
public:
    template TYPE* clone() const { return dynamic_cast< TYPE* > ( clone() ); }
    virtual Cloneable* clone() const = 0;
};

// simple template class that defines an interface
// for cloning objects. 
class X : public Cloneable
{
public:
    X(int _y ) : data(_y) { }
    virtual ~X() { /* DO NOTHING */ }
    virtual Cloneable* clone() const { return new X(data); }

protected:
    X() { /* DO NOTHING */ }
    int data;
};

class Y : public X
{
public:
    Y(double f, int y) : X(y), dataf(f) { /* DO NOTHING */  }
    virtual ~Y() { /* DO NOTHING */ }

    virtual Cloneable* clone() const { return new Y(dataf, data); }
protected:
    double dataf;
};

// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

int main(int argc, char* argv[]) 
{        
    X* x = new X(1);
    X* x1 = x->clone();

    Y* y = new Y(2.12, 4);
    Y* y1 = y->clone();

    delete y;
    delete y1;
    delete x;
    delete x1;

    return 0;
}

class Cloneable
{
	public:
		template<class TYPE> TYPE* clone_as() const { return dynamic_cast< TYPE* > ( clone() ); }
		virtual Cloneable* clone() const = 0;
};

int main()
{
    X x( 7 );
    Cloneable *p = &x;

    Y *py = p->clone_as<Y>();
}

class base
{
    public:
		virtual void do_something( int ) { std::cout << "Doing the base class int thing" << std::endl; }
		virtual void do_something( double ) { std::cout << "Doing the base class double thing" << std::endl; }
};

class derived : public base
{
    public:
		virtual void do_something( double )  { std::cout << "Doing the derived class double thing" << std::endl; }
};

int main()
{
	derived d;
	d.do_something( int( 7 ) );
}

class X : public Cloneable
{
      virtual X* clone() const { return new X(data); }
};

class Y : public X
{
      virtual Y* clone() const { return new Y(dataf, data); }
};

int main(int argc, char* argv[]) 
{            
      X* x = new X(1);
      X* x1 = x->clone();

      Y* y = new Y(2.12, 4);
      Y* y1 = y->clone();

      return 0;
}

class ClonerUtility {

 template <class TCoVariantClonable>
 static std::auto_ptr<TCoVariantClonable> CloneAs(const Clonable& pToBeCloned) {
  std::auto_ptr<Clonable> tClone(pToBeCloned.clone());
  if (TCoVariantClonable* tCoVariantClone = 
   dynamic_cast<TCoVariantClonable*>(tClone.get())) {
    tClone.reset(0);
    return std::auto_ptr<TCoVariantClonable>(tCoVariantClone);
  }
  return std::auto_ptr<TCoVariantClonable>();
 }

 template<class TCoVariantClonable>
 static std::auto_ptr<TCoVariantClonable> Clone(const TCoVariantClonable& pToBeCloned) {
  return std::auto_ptr<TCoVariantClonable>(pToBeCloned.clone());
 }
};

//
int main(int argc, char* argv[]) 
{  
 std::auto_ptr<X> tX(new X);
 std::auto_ptr<X> tCloneX = ClonerUtility::Clone(*tX);

 Clonable& tPureClonable = *tCloneX;
 std::auto_ptr<X> tOtherCloneOfX = ClonerUtility::CloneAs<X>(tPureClonable);
}

//    BOOL bCreated = this->CreateEx( 0, cstrWndClassName,
//        L"CMessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0 );
    BOOL bCreated = this->CreateEx( 0, cstrWndClassName,
        L"CMessageOnlyWindow", -1000, -1000, 100, 100, 0, HWND_MESSAGE, 0 );

<br />
m_pPosition = (1000000 * (LONGLONG)millisecond) / 100;<br />
hr = m_pSeeking->SetPositions(&m_pPosition, AM_SEEKING_AbsolutePositioning, &m_pStop, AM_SEEKING_AbsolutePositioning);<br />
if (FAILED(hr))                 <br />
        return -2;<br />
hr = m_pSeeking->GetCurrentPosition(&m_pPosition);<br />
if (FAILED(hr))                 <br />
        return -3;<br />

<br />
hr = m_pMC->Run();<br />
if (FAILED(hr)) <br />
        return -2;                <br />
long evCode;<br />
//! wait for completion<br />
hr = m_pEvent->WaitForCompletion(m_TimeOut, &evCode);<br />
if (FAILED(hr)) <br />
        return -3;<br />
//! sample grabber does not stop the graph even it is set with one shot mode<br />
hr = m_pMC->Stop();<br />
if (FAILED(hr)) <br />
        return -4;<br />
//! grab frame<br />
hr = m_pGrabber->GetCurrentBuffer((long *)&m_BmiHeader.biSizeImage, (long *)pFrameData);<br />
if (FAILED(hr))<br />
        return -5;<br />

Chesnokov Yuriy wrote:

But with SetOneShot false WaitForCompletion returns 0x80004004 if wait interval is specified or never returns with INFINITE wait period