Ejemplos de server_mode_t en C++ (Cpp)

Ejemplo n.º 1

Archivo: server.c Proyecto: klammerj/dvb-vulture

int
srvTuneTpi (PgmState * p, uint32_t pos, TransponderInfo * t)
{
  dvb_s *dvb = &p->dvb;
  int rv;
  if (dvbTuned (dvb))
  {
    dvbUnTune (dvb);
  }

  //wait for state change to propagate
  while ((!pgmdbUntuned (&p->program_database)) ||
#ifdef WITH_VT
         (!vtdbIdle (&p->videotext_database)) ||
#endif
#ifdef WITH_MHEG
         (!mhegIdle (&p->mheg)) ||
#endif
         (!epgdbIdle (&p->epg_database)) ||
         (!netWriterIdle (&p->net_writer)) || (!sapIdle (&p->sap_announcer)))
    usleep (300000);

  if (dvbIsSat (dvb))
  {
    rv = dvbTuneS (dvb, pos, t->frequency, t->srate, t->pol, t->ftune,
                   server_roff_t (t->roff), server_mod_t (t->mtype));
  }
  else if (dvbIsTerr (dvb))
  {
    rv = dvbTuneT (dvb, pos, t->frequency, t->inv,      //INVERSION_AUTO,
                   server_bandwidth_t (t->bw),
                   server_coderate_t (t->code_rate_h),
                   (t->hier & 3) ? server_coderate_t (t->code_rate_l) :
                   FEC_NONE, server_constellation_t (t->constellation),
                   server_mode_t (t->mode), server_guard_t (t->guard),
                   server_hier_t (t->hier), t->ftune);
  }
  else
  {
    errMsg ("unsupported delivery system (tuner)\n");
    rv = 1;
  }

  //again..
  if (rv == 0)
    while ((pgmdbUntuned (&p->program_database)) ||
#ifdef WITH_MHEG
           (mhegIdle (&p->mheg)) ||
#endif
#ifdef WITH_VT
           (vtdbIdle (&p->videotext_database)) ||
#endif
           (epgdbIdle (&p->epg_database)) ||
           (netWriterIdle (&p->net_writer)) || (sapIdle (&p->sap_announcer)))
      usleep (300000);
  return rv;
}

Ejemplo n.º 2

Archivo: main.cpp Proyecto: CCJY/coliru

namespace SWMR {
    static struct server_mode_t {} const/*expr*/ server_mode = server_mode_t();
    static struct client_mode_t {} const/*expr*/ client_mode = client_mode_t();

    typedef bip::interprocess_sharable_mutex mutex;
    typedef boost::lock_guard<mutex> guard;

    template <typename T, size_t N> struct SharedMemArray {
        SharedMemArray(server_mode_t, std::string const& name) 
          : isManager(true), _name(name), 
            _shm(do_create(_name.c_str())),
            _region(_shm, bip::read_write)
        {
            _data = new (_region.get_address()) data_t;
        }

        SharedMemArray(client_mode_t, std::string const& name) 
          : isManager(false), _name(name),
            _shm(do_open(_name.c_str())),
            _region(_shm, bip::read_write),
            _data(static_cast<data_t*>(_region.get_address()))
        {
            assert(sizeof(data_t) == _region.get_size());
        }

    private:
        BOOST_STATIC_ASSERT(boost::is_pod<T>::value);

        typedef bip::shared_memory_object shm_t;
        struct data_t { 
            mutable mutex mtx;
            T DataPtr[N];
        };

        bool               isManager;
        const std::string  _name;
        shm_t              _shm;
        bip::mapped_region _region;
        data_t            *_data;

        // functions to manage the shared memory
        shm_t static do_create(char const* name) {
            shm_t::remove(name);
            shm_t result(bip::create_only, name, bip::read_write);
            result.truncate(sizeof(data_t));
            return boost::move(result);
        }

        shm_t static do_open(char const* name) {
            return shm_t(bip::open_only, name, bip::read_write);
        }

      public:
        mutex& get_mutex() const { return _data->mtx; }

        typedef T       *iterator;
        typedef T const *const_iterator;

        iterator data()                { return _data->DataPtr; }
        const_iterator data() const    { return _data->DataPtr; }

        iterator begin()               { return data(); }
        const_iterator begin() const   { return data(); }

        iterator end()                 { return begin() + N; }
        const_iterator end() const     { return begin() + N; }

        const_iterator cbegin() const  { return begin(); }
        const_iterator cend() const    { return end(); }
    };
}