C++ precondition函数代码示例

/*----------------------------------------------------------------------
 Determine whether application *app needs to be updated.
 Returns latest app version from game server in *app.
 Not needed by most user programs.

 Returns dp_RES_OK if update needed,
 dp_RES_EMPTY if no update needed.
----------------------------------------------------------------------*/
DP_API dp_result_t DP_APIX dpCheckAppVersion(
	dp_t* dp,
	dp_appParam_t *app)
{
    precondition(dp);
    precondition(app);

	getLatest(dp, app);   /* Ignore errors */

	if ((app->latest.major == dp_VERS_UNKNOWN)
	||  (app->latest.minor == dp_VERS_UNKNOWN)) {
		DPRINT(("dpCheckAppVersion: no version info available for this app?\n"));
		return dp_RES_EMPTY;
	}
	if ((app->current.major > app->latest.major)
	||  ((app->current.major == app->latest.major)
	   && (app->current.minor >= app->latest.minor))) {
		DPRINT(("dpCheckAppVersion: this app is up to date.\n"));
		return dp_RES_EMPTY;
	}

	DPRINT(("dpCheckAppVersion: app needs updating: version cur %d/%d < latest %d/%d\n", 
			app->current.major, app->current.minor,
			app->latest.major, app->latest.minor));
	return dp_RES_OK;
}

BOOL Bsc1::getOverloadArray(SZ sz, MBF mbf, OUT IINST **ppiinst, OUT ULONG *pciinst)
{
    precondition(ppiinst);
    precondition(pciinst);
    IINST *rgiinst;
    ULONG cIinst;

    if (sz && sz[0] && sz[0] != '*') {
		Array<IINST> arIinst;
		parIinst = &arIinst;
		pbscCur  = this;
		GenerateOverloads(sz, mbf, GatherOverloads,this);
		cIinst = arIinst.size();
        rgiinst = (IINST*)malloc(cIinst*sizeof(IINST));
        if (!rgiinst) return FALSE;
	
		for (UINT i=0; i < cIinst; i++)
		    rgiinst[i] = arIinst[i];
    }
    else {
        rgiinst = (IINST*)malloc(cEntities*sizeof(IINST));
        if (!rgiinst) return FALSE;

        cIinst = 0;

        for (UINT i = 0; i < cEntities; i++) {
    	    if (fInstFilter(i, mbf) && fHasDefsOrRefs(i))
	    		rgiinst[cIinst++] = i;
        }
    }

    *ppiinst = rgiinst;
    *pciinst = cIinst;
    return TRUE;
}

        amg(const Matrix &M, const params &p = params()) : prm(p)
        {
            precondition(
                    backend::rows(M) == backend::cols(M),
                    "Matrix should be square!"
                    );

            boost::shared_ptr<build_matrix> P, R;
            boost::shared_ptr<build_matrix> A = boost::make_shared<build_matrix>( M );
            sort_rows(*A);

            while( backend::rows(*A) > prm.coarse_enough) {
                TIC("transfer operators");
                boost::tie(P, R) = Coarsening::transfer_operators(
                        *A, prm.coarsening);
                precondition(
                        backend::cols(*P) > 0,
                        "Zero-sized coarse level in amgcl (diagonal matrix?)"
                        );
                TOC("transfer operators");

                TIC("move to backend")
                levels.push_back( level(A, P, R, prm) );
                TOC("move to backend")

                TIC("coarse operator");
                A = Coarsening::coarse_operator(*A, *P, *R, prm.coarsening);
                sort_rows(*A);
                TOC("coarse operator");
            }

            TIC("coarsest level");
            levels.push_back( level(A, prm, levels.empty()) );
            TOC("coarsest level");
        }

int64_t
sample_rate::resample( int64_t i, const sample_rate &rate ) const
{
	precondition( _ratio.valid(), "invalid destination sample rate" );
	precondition( rate._ratio.valid(), "invalid source sample rate" );
	base::ratio tmp = i * ( _ratio / rate._ratio );
	return tmp.round();
}

void Loader::compositionExit()
{
  precondition(component != nullptr);
  precondition(composition != nullptr);

  component->setImplementation(composition);
  composition = nullptr;
}

void DrawPort::removeConnectionPoint(RelativePosition *point)
{
  precondition(point->hasAnchor());
  precondition(point->getAnchor() == &this->getPosition());

  point->removeAnchor();

  postcondition(!point->hasAnchor());
}

// create a BSC object using an existing PDB
PDBAPI(BOOL) Bsc::open(PDB* ppdb, OUT Bsc** ppbsc)
{
    precondition(ppbsc);
    precondition(ppdb);

    Bsc1* pbsc1 = new Bsc1;

    *ppbsc = pbsc1;
    if (!pbsc1) return FALSE;

    return pbsc1->init(ppdb);
}

void read_dense(const std::string &fname, SizeT &n, SizeT &m, std::vector<Val> &v)
{
    std::ifstream f(fname.c_str(), std::ios::binary);
    precondition(f, "Failed to open matrix file");

    precondition(read(f, n), "File I/O error");
    precondition(read(f, m), "File I/O error");

    v.resize(n * m);

    precondition(read(f, v), "File I/O error");
}

BOOL
MRE::FDelete() {
	precondition ( m_pstreamFileInfo );
	precondition ( m_pstreamClassMods );
	precondition ( m_pstreamFileMods );
	precondition ( m_pstreamRudeFiles );

	_TCHAR		szStreamName[ ctchMrePathMax ];
	Stream *	pstream;
	EnumMapNiFi	e(m_mpnifi);

	m_mrelog.LogNote ( "Note: deleting all streams.\n" );

	// enumerate all the src file streams
	while ( e.next() ) {
		PFI	pfi;
		NI	ni;
		e.get ( &ni, &pfi );
		assert ( ni == pfi->niFile );
		if ( pfi->FHasTarget() ) {
			pfi->SetFstatus ( fsmOutOfDate );
			_sntprintf ( szStreamName, countof(szStreamName), c_szMreFileFmt, ni );
			if ( m_ppdb->OpenStream ( szStreamName, &pstream ) ) {
				pstream->Truncate ( 0 );
				pstream->Release();
				}
			}
		}

	// invalidate the current buffer, if any
	m_mrfibufRoot.FInitEmpty();
	
	// get rid of the various streams
	m_pstreamClassInfo->Truncate ( 0 );
	m_pstreamClassMods->Truncate ( 0 );
	m_pstreamFileMods->Truncate ( 0 );
	m_pstreamRudeFiles->Truncate ( 0 );
	
	// get rid of the line change record data
	m_lcrechandler.Delete();
	
	// reset all the in memory copies of the streams
	m_mpnici.reset();
	m_rgtagniPending.reset();
	m_rgtagclsdep.reset();
	m_rgtagniRude.reset();
	m_itagclsdepSav = m_rgtagclsdep.size();
	m_ftagniPendingDirty = fFalse;
	m_itagniRudeSav = m_rgtagniRude.size();

	return fTrue;
	}

    ilu0( const Matrix &A, const params &, const typename Backend::params&)
        : luval( A.val ),
          dia  ( backend::rows(A) )
    {
        const size_t n = backend::rows(A);
        const value_type eps = amgcl::detail::eps<value_type>(1);

        std::vector<ptrdiff_t> work(n, -1);

        for(size_t i = 0; i < n; ++i) {
            ptrdiff_t row_beg = A.ptr[i];
            ptrdiff_t row_end = A.ptr[i + 1];

            for(ptrdiff_t j = row_beg; j < row_end; ++j)
                work[ A.col[j] ] = j;

            for(ptrdiff_t j = row_beg; j < row_end; ++j) {
                ptrdiff_t c = A.col[j];

                // Exit if diagonal is reached
                if (static_cast<size_t>(c) >= i) {
                    precondition(
                            static_cast<size_t>(c) == i,
                            "No diagonal value in system matrix"
                            );
                    precondition(
                            fabs(luval[j]) > eps,
                            "Zero pivot in ILU"
                            );

                    dia[i]   = j;
                    luval[j] = 1 / luval[j];
                    break;
                }

                // Compute the multiplier for jrow
                value_type tl = luval[j] * luval[dia[c]];
                luval[j] = tl;

                // Perform linear combination
                for(ptrdiff_t k = dia[c] + 1; k < A.ptr[c + 1]; ++k) {
                    ptrdiff_t w = work[A.col[k]];
                    if (w >= 0) luval[w] -= tl * luval[k];
                }
            }

            // Refresh work
            for(ptrdiff_t j = row_beg; j < row_end; ++j)
                work[A.col[j]] = -1;
        }
    }

int reduce_by_key_sink(
        IKTuple &&ikeys, vector<V> const &ivals,
        OKTuple &&okeys, vector<V>       &ovals,
        Comp, Oper
        )
{
    namespace fusion = boost::fusion;
    typedef typename extract_value_types<IKTuple>::type K;

    static_assert(
            std::is_same<K, typename extract_value_types<OKTuple>::type>::value,
            "Incompatible input and output key types");

    precondition(
            fusion::at_c<0>(ikeys).nparts() == 1 && ivals.nparts() == 1,
            "reduce_by_key is only supported for single device contexts"
            );

    precondition(fusion::at_c<0>(ikeys).size() == ivals.size(),
            "keys and values should have same size"
            );

    const auto &queue = fusion::at_c<0>(ikeys).queue_list();
    backend::select_context(queue[0]);

    const int NT_cpu = 1;
    const int NT_gpu = 256;
    const int NT = is_cpu(queue[0]) ? NT_cpu : NT_gpu;

    size_t count         = fusion::at_c<0>(ikeys).size();
    size_t num_blocks    = (count + NT - 1) / NT;
    size_t scan_buf_size = alignup(num_blocks, NT);

    backend::device_vector<int> key_sum   (queue[0], scan_buf_size);
    backend::device_vector<V>   pre_sum   (queue[0], scan_buf_size);
    backend::device_vector<V>   post_sum  (queue[0], scan_buf_size);
    backend::device_vector<V>   offset_val(queue[0], count);
    backend::device_vector<int> offset    (queue[0], count);

    /***** Kernel 0 *****/
    auto krn0 = offset_calculation<K, Comp>(queue[0]);

    krn0.push_arg(count);
    boost::fusion::for_each(ikeys, do_push_arg(krn0));
    krn0.push_arg(offset);

    krn0(queue[0]);

    VEX_FUNCTION(int, plus, (int, x)(int, y), return x + y;);

/*--------------------------------------------------------------------------
Save the apps list to disk.
(Called at quit time to provide quick info on next startup).
--------------------------------------------------------------------------*/
dp_result_t			/* status */
dp_freezeAppsList(
	dp_t *dp)		/* Owner of apps table */
{
	FILE* fp;
	dp_result_t err = dp_RES_OK;

	precondition(dp != NULL);
	precondition(dp->dpio != NULL);

	DPRINT(("dp_freezeAppsList:\n"));

	if (!dp->apps || (dptab_tableSize(dp->apps) == 0)) {
		DPRINT(("dptab_table_freeze: table has no entry\n"));
		return dp_RES_OK;
	}

	/* Get the file */
	fp = fopen(APPS_CACHE_FILE, "wb");
	if (fp == NULL) {
		DPRINT(("dp_freezeAppsList: can't open %s, errno %d\n", APPS_CACHE_FILE, errno));
		return dp_RES_FULL;
	}

	/* Write the info (either NULL or a table) */
	if(dp->apps != NULL) {
		char c = 1;
		if(fwrite(&c, sizeof(char), 1, fp) != 1) {
			fclose(fp);
			DPRINT(("dp_freezeAppsList: can't write %s, errno %d\n", APPS_CACHE_FILE, errno));
			return dp_RES_FULL;
		}
		err = dptab_table_freeze(dp->apps, dp->dpio, fp);
		DPRINT(("dp_freezeAppsList: fp now at %ld\n", ftell(fp)));
	} else {
		char c = 0;
		if(fwrite(&c, sizeof(char), 1, fp) != 1) {
			fclose(fp);
			DPRINT(("dp_freezeAppsList: can't write %s, errno %d\n", APPS_CACHE_FILE, errno));
			return dp_RES_FULL;
		}
	}

	/* Finish the file */
	fclose(fp);
	DPRINT(("dp_freezeAppsList: returning err:%d\n", err));
	return err;
}

void ComponentFactory::dispose(IComponent *component)
{
  precondition(component != nullptr);

  cleanup(*component);
  delete component;
}

 block_matrix_adapter(const Matrix &A) : A(A) {
     precondition(
             backend::rows(A) % BlockSize == 0 &&
             backend::cols(A) % BlockSize == 0,
             "Matrix size is not divisible by block size!"
             );
 }

    // Copy vector from builtin backend.
    static boost::shared_ptr<vector>
    copy_vector(typename builtin<real>::vector const &x, const params &prm)
    {
        precondition(!prm.context().empty(), "Empty VexCL context!");

        return boost::make_shared<vector>(prm.context(), x);
    }