C++ value::type方法代码示例

bool operator==(const value& lhs, const value& rhs) {
    if (lhs.type() != rhs.type()) {
        return false;
    }

    switch (static_cast<int>(lhs.type())) {
#define BSONCXX_ENUM(type, val) \
    case val:                   \
        return lhs.get_##type() == rhs.get_##type();
#include <bsoncxx/enums/type.hpp>
#undef BSONCXX_ENUM
    }

    BSONCXX_UNREACHABLE;
}

/// Like coerce(const value&) but assigns the value to a reference
/// instead of returning it.  May be more efficient for complex values
/// (arrays, maps, etc.)
///
/// @related proton::value
template<class T> void coerce(const value& v, T& x) {
    codec::decoder d(v, false);
    if (type_id_is_scalar(v.type())) {
        scalar s;
        d >> s;
        x = internal::coerce<T>(s);
    } else {

 static bool can_convert_from(const value& val) {
     if (val.type() != value_type::vector_type) {
         return false;
     }
     const auto& vec = val.get<value_vector_type>();
     return vec.size() == sizeof...(T)
         && tuple_value_converter<T...>::types_match(vec, 0);
 }

	static MetadataDefiniton get( value const &v )
	{
		MetadataDefiniton m;
		if( v.type( ) != is_object) {
			throw bad_value_cast( );
		}
		m.name = v.get<std::string>( "name" );
		m.type = v.get<std::string>( "type" );
		return m;
	}

	static PostingJoinOperatorConfiguration get( value const &v )
	{
		PostingJoinOperatorConfiguration c;
		if( v.type( ) != is_object ) {
			throw bad_value_cast( );
		}		
		c.name = v.get<std::string>( "name" );
		c.description = v.get<std::string>( "description" );
		return c;
	}

	static DocumentGetRequest get( value const &v )
	{
		DocumentGetRequest d;
		if( v.type( ) != is_object) {
			throw bad_value_cast( );
		}
		// TODO: should we also accept int, float? how can we fall back?
		d.docid = v.get<std::string>( "docid", "" );		
		
		return d;
	}

	static boost::tuple<std::string, std::string, strus::Index> get( value const &v )
	{
		boost::tuple<std::string, std::string, strus::Index> t;

		if( v.type( ) != is_object) {
			throw bad_value_cast( );
		}
		
		t = boost::make_tuple(
			v.get<std::string>( "type" ),
			v.get<std::string>( "value" ),
			v.get<strus::Index>( "pos" )
		);
				
		return t;
	}

static void GenStat(Stat& stat, const value& v) {
    switch (v.type()) {
    case value_type::array:
        {
            const array& a = array_cast(v);
            for (array::const_iterator itr = a.begin(); itr != a.end(); ++itr)
                GenStat(stat, *itr);
            stat.arrayCount++;
            stat.elementCount += a.size();
        }
        break;

    case value_type::object:
        {
            const object& o = object_cast(v);
            for (object::const_iterator itr = o.begin(); itr != o.end(); ++itr) {
                GenStat(stat, itr->second);
                stat.stringLength += itr->first.size();
            }
            stat.objectCount++;
            stat.memberCount += o.size();
            stat.stringCount += o.size();   // member names
        }
        break;

    case value_type::string: 
        stat.stringCount++;
        stat.stringLength += string_cast(v).length();
        break;

    case value_type::number:
        stat.numberCount++;
        break;

    case value_type::boolean:
        if (bool_cast(v))
            stat.trueCount++;
        else
            stat.falseCount++;
        break;

    case value_type::null:
        stat.nullCount++;
        break;
    }
}

void write_value(scanner& sc, writer& wr, const value& val) {
    switch (val.type()) {
    case value_type::number_type: {
        read_value(sc);
        wr.append(stringize_number(val.number_value()));
        break;
    }
    case value_type::string_type: {
        read_value(sc);
        wr.append("\"");
        wr.append(escape_string(val.string_value()));
        wr.append("\"");
        break;
    }
    case value_type::bool_type: {
        read_value(sc);
        wr.append(val.bool_value() ? "true" : "false");
        break;
    }
    case value_type::group_type: {
        if (sc.peek_token().is_char('{')) {
            write_group(sc, wr, true, val.group_value());
        } else {
            read_value(sc);
            scanner dummy_scanner = make_scanner("{}");
            write_group(dummy_scanner, wr, true, val.group_value());
        }
        break;
    }
    case value_type::vector_type: {
        if (sc.peek_token().is_char('[')) {
            write_vector(sc, wr, val.vector_value());
        } else {
            read_value(sc);
            scanner dummy_scanner = make_scanner("[]");
            write_vector(dummy_scanner, wr, val.vector_value());
        }
        break;
    }
    default: {
        break;
    }
    }
}

int value_length(const value& val, int wrap_length) {
    switch (val.type()) {
    case value_type::number_type: {
        return stringize_number(val.number_value()).size();
    }
    case value_type::string_type: {
        return 2 + escape_string(val.string_value()).size();
    }
    case value_type::bool_type: {
        return val.bool_value() ? 4 : 5;
    }
    case value_type::group_type: {
        return group_length(val.group_value());
    }
    case value_type::vector_type: {
        return vector_length(val.vector_value());
    }
    default: {
        return 0;
    }
    }
}

bool sqlitehandle::query (const string &sql, value &into,
						  const statstring &indexby)
{
	sqlite3_stmt *qhandle;
	int qres;
	int rowcount=0;
	int colcount;
	int i;
	statstring curidx;
	bool done = false;
	
	into.clear ();
	
	if (sqlite3_prepare (hdl, sql.str(), sql.strlen(), &qhandle, 0) != SQLITE_OK)
	{
		errcode = 1;
		errstr = "Could not prepare: %s" %format (sqlite3_errmsg(hdl));
		return false;
	}
	
	if (! (qres = sqlite3_step (qhandle)))
	{
		errcode = 1;
		errstr = "Error making first step: %s" %format (sqlite3_errmsg(hdl));
		sqlite3_finalize (qhandle);
		return false;
	}
	
	colcount = sqlite3_column_count (qhandle);
	if (colcount == 0)
	{
		into("rowschanged") = sqlite3_changes (hdl);
		sqlite3_finalize (qhandle);
		return true;
	}
	
	statstring colnames[colcount];
	value colidx;
	
	for (i=0; i<colcount; ++i)
	{
		colnames[i] = sqlite3_column_name (qhandle, i);
		colidx[colnames[i]] = i;
	}
	
	int indexfield = -1;
	if (colidx.exists (indexby)) indexfield = colidx[indexby];
	
	if (! done) do
	{
		switch (qres)
		{
			case SQLITE_BUSY:
				sleep (1);
				sqlite3_reset(qhandle);
				continue;
			
			case SQLITE_MISUSE: // achtung, fallthrough
			case SQLITE_ERROR:
				errcode = 1;
				errstr = "Error in sqlite3_step: %s" %format (sqlite3_errmsg(hdl));
				done = true;
				break;

			case SQLITE_DONE:
				done = true;
				break;
				
			case SQLITE_ROW:
				{
					if (indexfield>=0)
					{
						curidx = sqlite3_column_text (qhandle, indexfield);
					}
					
					value &myrow = (indexfield<0) ? into.newval() : into[curidx];
					
					for (int i=0; i<colcount; i++)
					{
						int ctype = sqlite3_column_type (qhandle, i);
						statstring &curcol = colnames[i];
						
						switch (ctype)
						{
							case SQLITE_INTEGER:
								myrow[curcol] = sqlite3_column_int (qhandle, i);
								break;
							
							case SQLITE_FLOAT:
								myrow[curcol] = sqlite3_column_double (qhandle, i);
								break;
							
							case SQLITE_BLOB:
								// FIXME: use sqlite3_column_blob
							case SQLITE_TEXT:
								myrow[curcol] = sqlite3_column_text (qhandle, i);
								break;
							
							default:
								break;
//.........这里部分代码省略.........

value flatten(value const& v) {
  return {flatten(v.data()), flatten(v.type())};
}

 /// Type-safe factory function to construct an event from an unchecked value.
 /// @param v The value to check and convert into an event.
 /// @returns A valid event according *v* if `v.type().check(v.data())`.
 static event make(value v) {
   return type_check(v.type(), v.data()) ? event{std::move(v)} : caf::none;
 }