自学教程：C++ typeOf函数代码示例

int main(int argc, char** argv) try{    if (argc < 2) {        std::cerr << "usage: " << argv[0] << " path" << std::endl;        return 1;    }     QCoreApplication app(argc, argv);    QEventLoop loop;        QString const path = QFile::decodeName(argv[1]);        lastfm::Track t = lastfm::taglib(path); //see contrib //TODO mbid    lastfm::Fingerprint fp(t);    if (fp.id().isNull()) {        lastfm::FingerprintableSource* src = factory(typeOf(path));        fp.generate(src);        QNetworkReply* reply = fp.submit();        loop.connect(reply, SIGNAL(finished()), SLOT(quit()));        fp.decode(reply);    }        QNetworkReply* reply = fp.id().getSuggestions();    loop.connect(reply, SIGNAL(finished()), SLOT(quit()));        std::cout << reply->readAll().data() << std::endl; //returns XML    return 0;}catch (std::exception& e){    std::cerr << e.what() << std::endl;}

static void *fr_prc_ctor (void *ap_obj, va_list * app){  fr_prc_t *p_prc = super_ctor (typeOf (ap_obj, "frprc"), ap_obj, app);  assert (p_prc);  return p_prc;}

static void *spfysrc_cfgport_ctor (void *ap_obj, va_list *app){  spfysrc_cfgport_t *p_obj      = super_ctor (typeOf (ap_obj, "spfysrccfgport"), ap_obj, app);  assert (p_obj);  tiz_check_omx_err_ret_null (tiz_port_register_index (      p_obj, OMX_TizoniaIndexParamAudioSpotifySession));  tiz_check_omx_err_ret_null (tiz_port_register_index (      p_obj, OMX_TizoniaIndexParamAudioSpotifyPlaylist));  /* Initialize the OMX_TIZONIA_AUDIO_PARAM_SPOTIFYSESSIONTYPE structure */  TIZ_INIT_OMX_STRUCT (p_obj->spotifysession_);  snprintf ((char *)p_obj->spotifysession_.cUserName,            sizeof(p_obj->spotifysession_.cUserName), "tizonia");  snprintf ((char *)p_obj->spotifysession_.cUserPassword,            sizeof(p_obj->spotifysession_.cUserPassword), "pass");  p_obj->spotifysession_.bRememberCredentials = OMX_TRUE;  p_obj->spotifysession_.ePreferredBitRate = OMX_AUDIO_SpotifyBitrate320Kbps;  p_obj->spotifysession_.eConnectionType      = OMX_AUDIO_SpotifyConnectionMobileWired;  /* Initialize the OMX_TIZONIA_AUDIO_PARAM_SPOTIFYPLAYLISTTYPE structure */  TIZ_INIT_OMX_STRUCT (p_obj->playlist_);  snprintf ((char *)p_obj->playlist_.cPlaylistName,            sizeof(p_obj->playlist_.cPlaylistName), "playlist");  p_obj->playlist_.bShuffle = OMX_FALSE;  return p_obj;}

static OMX_ERRORTYPEpausetoidle_trans_complete (const void *ap_obj,                            OMX_PTR ap_servant, OMX_STATETYPE a_new_state){  const tiz_state_t *p_base = (const tiz_state_t *) ap_obj;  TIZ_TRACE (handleOf (ap_obj),            "Trans complete to state [%s]...",            tiz_fsm_state_to_str (a_new_state));  assert (OMX_StateIdle == a_new_state);  assert (NULL != ap_obj);  assert (NULL != ap_servant);  assert (OMX_StateIdle == a_new_state);  if (2 == p_base->servants_count_ + 1)    {      /* Reset the OMX_TIZONIA_PORTSTATUS_AWAITBUFFERSRETURN flag in all ports         where this has been set */      tiz_krn_reset_tunneled_ports_status        (tiz_get_krn (handleOf(ap_servant)),         OMX_TIZONIA_PORTSTATUS_AWAITBUFFERSRETURN);    }  return tiz_state_super_trans_complete (typeOf (ap_obj, "tizpausetoidle"), ap_obj, ap_servant,                                        a_new_state);}

static OMX_ERRORTYPEscloud_cfgport_GetParameter (const void * ap_obj, OMX_HANDLETYPE ap_hdl,                             OMX_INDEXTYPE a_index, OMX_PTR ap_struct){  const scloud_cfgport_t * p_obj = ap_obj;  OMX_ERRORTYPE rc = OMX_ErrorNone;  assert (p_obj);  TIZ_TRACE (ap_hdl, "PORT [%d] GetParameter [%s]...", tiz_port_index (ap_obj),             tiz_idx_to_str (a_index));  if (OMX_TizoniaIndexParamAudioSoundCloudSession == a_index)    {      memcpy (ap_struct, &(p_obj->session_),              sizeof (OMX_TIZONIA_AUDIO_PARAM_SOUNDCLOUDSESSIONTYPE));    }  else if (OMX_TizoniaIndexParamAudioSoundCloudPlaylist == a_index)    {      memcpy (ap_struct, &(p_obj->playlist_),              sizeof (OMX_TIZONIA_AUDIO_PARAM_SOUNDCLOUDPLAYLISTTYPE));    }  else    {      /* Delegate to the base port */      rc = super_GetParameter (typeOf (ap_obj, "scloudcfgport"), ap_obj, ap_hdl,                               a_index, ap_struct);    }  return rc;}

static OMX_ERRORTYPEloadedtoidle_tunneled_ports_status_update (void * ap_obj){  tiz_state_t * p_base = (tiz_state_t *) ap_obj;  assert (ap_obj);  {    OMX_HANDLETYPE p_hdl = handleOf (p_base->p_fsm_);    void * p_krn = tiz_get_krn (p_hdl);    if (TIZ_KRN_MAY_INIT_ALLOC_PHASE (p_krn))      {        /* OK, at this point all the tunneled non-supplier neighboring ports         * are ready to receive OMX_UseBuffer calls. IL resource allocation         * will take place now */        /* NOTE: This will call the 'tiz_state_state_set' function of the base         * class (we are passing 'tizloaded' as the 1st parameter */        return tiz_state_super_state_set (typeOf (ap_obj, "tizloaded"), ap_obj,                                          p_hdl, OMX_CommandStateSet,                                          OMX_StateIdle, NULL);      }  }  return OMX_ErrorNone;}

static void *scloud_cfgport_ctor (void * ap_obj, va_list * app){  scloud_cfgport_t * p_obj    = super_ctor (typeOf (ap_obj, "scloudcfgport"), ap_obj, app);  assert (p_obj);  tiz_check_omx_ret_null (tiz_port_register_index (    p_obj, OMX_TizoniaIndexParamAudioSoundCloudSession));  tiz_check_omx_ret_null (tiz_port_register_index (    p_obj, OMX_TizoniaIndexParamAudioSoundCloudPlaylist));  /* Initialize the OMX_TIZONIA_AUDIO_PARAM_SOUNDCLOUDSESSIONTYPE structure */  TIZ_INIT_OMX_STRUCT (p_obj->session_);  snprintf ((char *) p_obj->session_.cUserName,            sizeof (p_obj->session_.cUserName), "tizonia");  snprintf ((char *) p_obj->session_.cUserPassword,            sizeof (p_obj->session_.cUserPassword), "pass");  snprintf ((char *) p_obj->session_.cUserOauthToken,            sizeof (p_obj->session_.cUserOauthToken),            "1-111111-11111111-11111111111111");  /* Initialize the OMX_TIZONIA_AUDIO_PARAM_SOUNDCLOUDPLAYLISTTYPE structure */  TIZ_INIT_OMX_STRUCT (p_obj->playlist_);  snprintf ((char *) p_obj->playlist_.cPlaylistName,            sizeof (p_obj->playlist_.cPlaylistName), "playlist");  p_obj->playlist_.ePlaylistType = OMX_AUDIO_SoundCloudPlaylistTypeUnknown;  p_obj->playlist_.bShuffle = OMX_FALSE;  return p_obj;}

static void *idletoloaded_ctor (void * ap_obj, va_list * app){  tiz_idletoloaded_t * p_obj    = super_ctor (typeOf (ap_obj, "tizidletoloaded"), ap_obj, app);  return p_obj;}

static OMX_ERRORTYPEpausetoidle_tunneled_ports_status_update (void *ap_obj){  tiz_state_t *p_base = (tiz_state_t *) ap_obj;  assert (NULL != ap_obj);  {    OMX_HANDLETYPE p_hdl = handleOf(p_base->p_fsm_);    void *p_krn = tiz_get_krn (p_hdl);    if (TIZ_KRN_MAY_INIT_EXE_TO_IDLE (p_krn))      {        /* OK, at this point all the tunneled non-supplier neighboring ports           are ready to receive ETB/FTB calls.  NOTE: This will call the         * 'tiz_state_state_set' function of the tiz_state_t base class (note         * we are passing 'tizidle' as 1st parameter */        TIZ_TRACE (p_hdl, "kernel may initiate pause to idle");        return tiz_state_super_state_set (typeOf (ap_obj, "tizidle"), ap_obj, p_hdl,                                         OMX_CommandStateSet,                                         OMX_StateIdle, NULL);      }  }  return OMX_ErrorNone;}

static OMX_ERRORTYPEcc_http_prc_deallocate_resources (void * ap_prc){  delete_url (ap_prc);  return tiz_srv_super_deallocate_resources (typeOf (ap_prc, "cc_httpprc"),                                             ap_prc);}

static void *fr_prc_ctor (void *ap_obj, va_list * app){  fr_prc_t *p_obj = super_ctor (typeOf (ap_obj, "frprc"), ap_obj, app);  p_obj->eos_ = false;  return p_obj;}

static void *oggdmux_prc_ctor (void * ap_obj, va_list * app){  oggdmux_prc_t * p_prc    = super_ctor (typeOf (ap_obj, "oggdmuxprc"), ap_obj, app);  assert (p_prc);  p_prc->p_file_ = NULL;  p_prc->p_uri_ = NULL;  p_prc->p_oggz_ = NULL;  p_prc->p_tracks_ = NULL;  p_prc->p_aud_hdr_ = NULL;  p_prc->p_vid_hdr_ = NULL;  p_prc->aud_buf_size_ = 0;  p_prc->vid_buf_size_ = 0;  p_prc->awaiting_buffers_ = true;  p_prc->p_aud_store_ = NULL;  p_prc->p_vid_store_ = NULL;  p_prc->aud_store_size_ = 0;  p_prc->vid_store_size_ = 0;  p_prc->aud_store_offset_ = 0;  p_prc->vid_store_offset_ = 0;  p_prc->file_eos_ = false;  p_prc->aud_eos_ = false;  p_prc->vid_eos_ = false;  p_prc->aud_port_disabled_ = false;  p_prc->vid_port_disabled_ = false;  return p_prc;}

static void *cc_plex_cfgport_ctor (void * ap_obj, va_list * app){  cc_plex_cfgport_t * p_obj    = super_ctor (typeOf (ap_obj, "cc_plexcfgport"), ap_obj, app);  assert (p_obj);  tiz_check_omx_ret_null (tiz_port_register_index (    p_obj, OMX_TizoniaIndexParamAudioPlexSession));  tiz_check_omx_ret_null (tiz_port_register_index (    p_obj, OMX_TizoniaIndexParamAudioPlexPlaylist));  /* Initialize the OMX_TIZONIA_AUDIO_PARAM_PLEXSESSIONTYPE structure */  TIZ_INIT_OMX_STRUCT (p_obj->session_);  snprintf ((char *) p_obj->session_.cBaseUrl,            sizeof (p_obj->session_.cBaseUrl), "xyzxyzxyzxyzxyz");  snprintf ((char *) p_obj->session_.cAuthToken,            sizeof (p_obj->session_.cAuthToken), "xyzxyzxyzxyzxyz");  /* Initialize the OMX_TIZONIA_AUDIO_PARAM_PLEXPLAYLISTTYPE structure */  TIZ_INIT_OMX_STRUCT (p_obj->playlist_);  snprintf ((char *) p_obj->playlist_.cPlaylistName,            sizeof (p_obj->playlist_.cPlaylistName), "playlist");  p_obj->playlist_.ePlaylistType = OMX_AUDIO_PlexPlaylistTypeUnknown;  p_obj->playlist_.bShuffle = OMX_FALSE;  return p_obj;}

static void *loadedtoidle_ctor (void * ap_obj, va_list * app){  tiz_loadedtoidle_t * p_obj    = super_ctor (typeOf (ap_obj, "tizloadedtoidle"), ap_obj, app);  return p_obj;}

static void *waitforresources_ctor (void *ap_obj, va_list * app){  tiz_waitforresources_t *p_obj =    super_ctor (typeOf (ap_obj, "tizwaitforresources"), ap_obj, app);  return p_obj;}

static void *cc_http_prc_ctor (void * ap_obj, va_list * app){  cc_http_prc_t * p_prc    = super_ctor (typeOf (ap_obj, "cc_httpprc"), ap_obj, app);  p_prc->p_content_uri_ = NULL;  return p_prc;}

static OMX_ERRORTYPEloadedtoidle_state_set (const void * ap_obj, OMX_HANDLETYPE ap_hdl,                        OMX_COMMANDTYPE a_cmd, OMX_U32 a_param1,                        OMX_PTR ap_cmd_data){  tiz_state_t * p_base = (tiz_state_t *) ap_obj;  tiz_fsm_state_id_t new_state = EStateMax;  assert (ap_obj);  assert (ap_hdl);  assert (a_cmd == OMX_CommandStateSet);  TIZ_TRACE (ap_hdl,             "Requested transition "             "[ESubStateLoadedToIdle -> %s]...",             tiz_fsm_state_to_str (a_param1));  /* Allowed transitions are OMX_StateLoaded only (a.k.a. transition   * cancellation). */  switch (a_param1)    {      case OMX_StateLoaded:        {          new_state = ESubStateIdleToLoaded;        }        break;      default:        {          TIZ_ERROR (ap_hdl,                     "[OMX_ErrorIncorrectStateTransition] : "                     "ESubStateLoadedToIdle -> [%s]",                     tiz_state_to_str (a_param1));          return OMX_ErrorIncorrectStateTransition;        }    };  /* reset here the servants count */  p_base->servants_count_ = 0;  if (ESubStateIdleToLoaded == new_state)    {      OMX_ERRORTYPE rc = OMX_ErrorNone;      if (OMX_ErrorNone          != (rc = tiz_fsm_set_state (tiz_get_fsm (ap_hdl), new_state,                                      ESubStateLoadedToIdle)))        {          return rc;        }    }  /* IL resource deallocation should take place now */  /* NOTE: This will call the 'tiz_state_state_set' function and not   * 'tizloaded_state_set' (we are passing 'tizloaded' as the 1st   * parameter  */  return tiz_state_super_state_set (typeOf (ap_obj, "tizloaded"), ap_obj,                                    ap_hdl, a_cmd, a_param1, ap_cmd_data);}

static void *sdlivr_proc_ctor (void *ap_obj, va_list * app){  sdlivr_prc_t *p_prc = super_ctor (typeOf (ap_obj, "sdlivrprc"), ap_obj, app);  assert (NULL != p_prc);  p_prc->pinhdr_ = NULL;  p_prc->pouthdr_ = NULL;  p_prc->eos_ = false;  return p_prc;}

static OMX_ERRORTYPEidletoloaded_trans_complete (const void * ap_obj, OMX_PTR ap_servant,                             OMX_STATETYPE a_new_state){  TIZ_TRACE (handleOf (ap_servant), "Trans complete to state [%s]...",             tiz_fsm_state_to_str ((tiz_fsm_state_id_t) a_new_state));  assert (OMX_StateLoaded == a_new_state);  return tiz_state_super_trans_complete (typeOf (ap_obj, "tizidletoloaded"),                                         ap_obj, ap_servant, a_new_state);}

static OMX_ERRORTYPEloadedtoidle_SetParameter (const void * ap_obj, OMX_HANDLETYPE ap_hdl,                           OMX_INDEXTYPE a_index, OMX_PTR ap_struct){  /* In this transitional state, OMX_SetParameter should only be allowed */  /* until the first OMX_UseBuffer call is received */  TIZ_TRACE (ap_hdl, "[%s]", tiz_idx_to_str (a_index));  return super_SetParameter (typeOf (ap_obj, "tizloadedtoidle"), ap_obj, ap_hdl,                             a_index, ap_struct);}

static void *httpr_prc_ctor (void * ap_prc, va_list * app){  httpr_prc_t * p_prc = super_ctor (typeOf (ap_prc, "httprprc"), ap_prc, app);  assert (p_prc);  p_prc->mount_name_ = NULL;  p_prc->port_disabled_ = false;  p_prc->p_server_ = NULL;  p_prc->p_inhdr_ = NULL;  return p_prc;}

static OMX_ERRORTYPEcc_http_prc_allocate_resources (void * ap_obj, OMX_U32 a_pid){  cc_http_prc_t * p_prc = ap_obj;  assert (p_prc);  tiz_check_omx (tiz_srv_super_allocate_resources (typeOf (p_prc, "cc_httpprc"),                                                   p_prc, a_pid));  return obtain_url (ap_obj);}

void		*itr_ctor(void *_self, va_list *ap){  t_itr	*self = (t_itr *)_self;  t_list *list = va_arg(*ap, t_list *);  assert(typeOf(list) == List);  self->list = list;  self->cur = list->first;  self->next = (self->cur ? self->cur->next : NULL);  return (_self);  }

static OMX_ERRORTYPE httpr_mp3port_GetConfig (const void *ap_obj,                                              OMX_HANDLETYPE ap_hdl,                                              OMX_INDEXTYPE a_index,                                              OMX_PTR ap_struct){  const httpr_mp3port_t *p_obj = ap_obj;  OMX_ERRORTYPE rc = OMX_ErrorNone;  TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index));  assert (NULL != p_obj);  if (OMX_TizoniaIndexConfigIcecastMetadata == a_index)    {      OMX_TIZONIA_ICECASTMETADATATYPE *p_metadata          = (OMX_TIZONIA_ICECASTMETADATATYPE *)ap_struct;      p_metadata->nVersion.nVersion = OMX_VERSION;      if (NULL != p_obj->p_stream_title_)        {          OMX_U32 metadata_buf_size = p_metadata->nSize - sizeof(OMX_U32)                                      - sizeof(OMX_VERSIONTYPE)                                      - sizeof(OMX_U32);          OMX_U32 stream_title_len = strnlen (              p_obj->p_stream_title_, OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE);          assert (stream_title_len < OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE);          if (metadata_buf_size < (stream_title_len + 1)              && metadata_buf_size < OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE)            {              rc = OMX_ErrorBadParameter;            }          else            {              strncpy ((char *)p_metadata->cStreamTitle,                       p_obj->p_stream_title_, stream_title_len);              p_metadata->cStreamTitle[stream_title_len] = '/000';            }        }      else        {          p_metadata->cStreamTitle[0] = '/000';        }    }  else    {      /* Delegate to the base port */      rc = super_GetConfig (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl,                            a_index, ap_struct);    }  return rc;}

void PlanRep::collapseVertices(const OrthoRep &OR, GridLayout &drawing){	for (node v : nodes) {		const OrthoRep::VertexInfoUML *vi = OR.cageInfo(v);		if(vi == nullptr ||			(typeOf(v) != Graph::highDegreeExpander &&			typeOf(v) != Graph::lowDegreeExpander))			continue;		node vOrig = original(v);		OGDF_ASSERT(vOrig != 0);		node vCenter = newNode();		m_vOrig[vCenter] = vOrig;		m_vCopy[vOrig] = vCenter;		m_vOrig[v] = nullptr;		node lowerLeft  = vi->m_corner[odNorth]->theNode();		node lowerRight = vi->m_corner[odWest ]->theNode();		node upperLeft  = vi->m_corner[odEast ]->theNode();		drawing.x(vCenter) = (drawing.x(lowerLeft)+drawing.x(lowerRight)) >> 1;		drawing.y(vCenter) = (drawing.y(lowerLeft)+drawing.y(upperLeft )) >> 1;		edge eOrig;		forall_adj_edges(eOrig,vOrig) {			if(eOrig->target() == vOrig) {				node connect = m_eCopy[eOrig].back()->target();				edge eNew = newEdge(connect,vCenter);				m_eOrig[eNew] = eOrig;				m_eIterator[eNew] = m_eCopy[eOrig].pushBack(eNew);			} else {				node connect = m_eCopy[eOrig].front()->source();				edge eNew = newEdge(vCenter,connect);				m_eOrig[eNew] = eOrig;				m_eIterator[eNew] = m_eCopy[eOrig].pushFront(eNew);			}		}	}}

static void *vorbisd_prc_ctor (void *ap_obj, va_list *app){  vorbisd_prc_t *p_prc      = super_ctor (typeOf (ap_obj, "vorbisdprc"), ap_obj, app);  assert (NULL != p_prc);  p_prc->p_fsnd_ = NULL;  reset_stream_parameters (p_prc);  p_prc->p_store_ = NULL;  p_prc->store_size_ = 0;  p_prc->store_offset_ = 0;  return p_prc;}