Changeset 89a22be in rtems


Ignore:
Timestamp:
Oct 8, 2020, 11:44:36 PM (10 months ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
558a19d3
Parents:
6f2a219f
git-author:
Chris Johns <chrisj@…> (10/08/20 23:44:36)
git-committer:
Chris Johns <chrisj@…> (10/08/20 23:46:25)
Message:

librtemscxx: Fix white space to match the coding standard

Location:
cpukit
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • cpukit/include/rtems/error.hpp

    r6f2a219f r89a22be  
    5151    const rtems_status_code sc;
    5252  public:
    53     runtime_error (const rtems_status_code sc);
    54     runtime_error (const rtems_status_code sc, const std::string& what);
    55     runtime_error (const rtems_status_code sc, const char* what);
    56     ~runtime_error ();
     53    runtime_error(const rtems_status_code sc);
     54    runtime_error(const rtems_status_code sc, const std::string& what);
     55    runtime_error(const rtems_status_code sc, const char* what);
     56    ~runtime_error();
    5757  };
    5858
     
    6161   * not RTEMS_SUCCESSFUL.
    6262   */
    63   void runtime_error_check (const rtems_status_code sc);
    64   void runtime_error_check (const rtems_status_code sc, const std::string& what);
    65   void runtime_error_check (const rtems_status_code sc, const char* what);
     63  void runtime_error_check(const rtems_status_code sc);
     64  void runtime_error_check(const rtems_status_code sc, const std::string& what);
     65  void runtime_error_check(const rtems_status_code sc, const char* what);
    6666};
    6767
  • cpukit/include/rtems/thread.hpp

    r6f2a219f r89a22be  
    8484       * stack size.
    8585       */
    86       attributes ();
     86      attributes();
    8787
    8888      /*
     
    9191       * @param attr The attributes to copy.
    9292       */
    93       attributes (const attributes& attr);
     93      attributes(const attributes& attr);
    9494
    9595      /**
     
    9999       * @param name The name as a string.
    100100       */
    101       void set_name (const std::string& name);
     101      void set_name(const std::string& name);
    102102
    103103      /**
     
    107107       * @param name The name as a string.
    108108       */
    109       void set_name (const char* name);
     109      void set_name(const char* name);
    110110
    111111      /**
     
    114114       * @retval const std::string& The name of the thread.
    115115       */
    116       const std::string& get_name () const;
     116      const std::string& get_name() const;
    117117
    118118      /**
     
    121121       * @param priority The POSIX API priority of the thread.
    122122       */
    123       void set_priority (int priority);
     123      void set_priority(int priority);
    124124
    125125      /**
     
    128128       * @retval int The POSIX API thread priority.
    129129       */
    130       int get_priority () const;
     130      int get_priority() const;
    131131
    132132      /**
     
    136136       * @param size The stack size in bytes.
    137137       */
    138       void set_stack_size (size_t size);
     138      void set_stack_size(size_t size);
    139139
    140140      /**
     
    143143       * @retval size_t The stack size in bytes.
    144144       */
    145       size_t get_stack_size () const;
     145      size_t get_stack_size() const;
    146146
    147147      /**
     
    150150       * @parrm scheduler The name of the scheduler.
    151151       */
    152       void set_scheduler (const std::string& scheduler);
     152      void set_scheduler(const std::string& scheduler);
    153153
    154154      /**
    155155       * Set the scheduler name. If not set no scheduler is set.
    156156       */
    157       void set_scheduler (const char* scheduler);
     157      void set_scheduler(const char* scheduler);
    158158
    159159      /**
    160160       * Get scheduler name.
    161161       */
    162       const std::string& get_scheduler ();
     162      const std::string& get_scheduler();
    163163
    164164      /**
     
    167167       * @return sched_attr The attributes' scheduler attribute
    168168       */
    169       sched_attr get_scheduler_attr () const;
     169      sched_attr get_scheduler_attr() const;
    170170
    171171      /**
     
    175175       * @param policy The scheduler policy.
    176176       */
    177       void set_scheduler_policy (sched_policy policy);
     177      void set_scheduler_policy(sched_policy policy);
    178178
    179179      /**
    180180       * Get the scheduler policy for the thread.
    181181       */
    182       sched_policy get_scheduler_policy () const;
     182      sched_policy get_scheduler_policy() const;
    183183
    184184      /**
     
    188188       * name and stack size are ignored.
    189189       */
    190       void commit ();
     190      void commit();
    191191
    192192      /**
     
    198198       * changes made will lost then the update call is made.
    199199       */
    200       void update ();
     200      void update();
    201201
    202202      /**
    203203       * Copy operator.
    204204       */
    205       attributes& operator= (const attributes& attr);
     205      attributes& operator=(const attributes& attr);
    206206
    207207      /**
     
    209209       * of a thread.
    210210       */
    211       bool operator== (const attributes& attr) const;
     211      bool operator==(const attributes& attr) const;
    212212
    213213    private:
     
    244244    class thread
    245245    {
    246       friend void* thread_generic_entry (void* arg);
     246      friend void* thread_generic_entry(void* arg);
    247247
    248248      /**
     
    252252      struct state_base
    253253      {
    254         virtual ~state_base ();
    255         virtual const attributes get_attributes () = 0;
    256         virtual void run () = 0;
     254        virtual ~state_base();
     255        virtual const attributes get_attributes() = 0;
     256        virtual void run() = 0;
    257257      };
    258258
     
    279279      class id {
    280280      public:
    281         id () noexcept : id_ (0) { }
    282         explicit id (pthread_t id_) : id_ (id_) { }
     281        id() noexcept : id_(0) { }
     282        explicit id(pthread_t id_) : id_(id_) { }
    283283      private:
    284284        pthread_t id_;
    285285
    286286        friend class thread;
    287         friend bool operator== (thread::id l, thread::id r) noexcept;
     287        friend bool operator==(thread::id l, thread::id r) noexcept;
    288288
    289289        template<class CharT, class Traits>
    290290        friend std::basic_ostream<CharT, Traits>&
    291         operator<< (std::basic_ostream<CharT, Traits>& out, thread::id id_);
     291        operator<<(std::basic_ostream<CharT, Traits>& out, thread::id id_);
    292292      };
    293293
     
    295295       * The default thread constructions.
    296296       */
    297       thread () noexcept = default;
     297      thread() noexcept = default;
    298298
    299299      /**
     
    303303       */
    304304      template<typename F, typename... Args>
    305       explicit thread (F&& func, Args&&... args);
     305      explicit thread(F&& func, Args&&... args);
    306306
    307307      /**
     
    311311      template <typename A, typename F, typename ...Args,
    312312                class = enable_if_attributes<A>>
    313       explicit thread (A&& attr, F&& func, Args&&... args);
     313      explicit thread(A&& attr, F&& func, Args&&... args);
    314314
    315315      /**
    316316       * Move the thread id to this instance.
    317317       */
    318       thread& operator= (thread&& thread_);
     318      thread& operator=(thread&& thread_);
    319319
    320320      void swap(thread& thread_) noexcept;
     
    329329       * Constrain use. These are not available.
    330330       */
    331       thread (thread&) = delete;
    332       thread (const thread&) = delete;
    333       thread (const thread&&) = delete;
    334       thread& operator= (const thread&) = delete;
     331      thread(thread&) = delete;
     332      thread(const thread&) = delete;
     333      thread(const thread&&) = delete;
     334      thread& operator=(const thread&) = delete;
    335335
    336336      std::thread::id get_id() const noexcept;
     
    350350
    351351        template<size_t Index>
    352         static std::__tuple_element_t<Index, Parms>&& declval ();
     352        static std::__tuple_element_t<Index, Parms>&& declval();
    353353
    354354        template<size_t... Ind>
    355         auto invoke (std::_Index_tuple<Ind...>)
    356           noexcept (noexcept (std::invoke (declval<Ind>()...)))
    357           -> decltype (std::invoke (declval<Ind> ()...)) {
    358           return std::invoke (std::get<Ind> (std::move (p))...);
     355        auto invoke(std::_Index_tuple<Ind...>)
     356          noexcept(noexcept(std::invoke(declval<Ind>()...)))
     357          -> decltype(std::invoke(declval<Ind>()...)) {
     358          return std::invoke(std::get<Ind>(std::move(p))...);
    359359        }
    360360
     
    362362          typename std::_Build_index_tuple<std::tuple_size<Parms>::value>::__type;
    363363
    364         void run () {
    365           invoke (indices ());
     364        void run() {
     365          invoke(indices());
    366366        }
    367367      };
     
    377377        Invoker          i;
    378378
    379         state (const attributes& attr, Invoker&& i)
    380           : attr (attr),
    381             i (std::forward<Invoker> (i)) {
     379        state(const attributes& attr, Invoker&& i)
     380          : attr(attr),
     381            i(std::forward<Invoker>(i)) {
    382382        }
    383383
    384         const attributes get_attributes () override {
     384        const attributes get_attributes() override {
    385385          return attr;
    386386        }
    387387
    388         void run () override {
    389           i.run ();
     388        void run() override {
     389          i.run();
    390390        }
    391391      };
     
    397397      template<typename Invoker>
    398398      static state_ptr
    399       make_state (const attributes& attr, Invoker&& i) {
     399      make_state(const attributes& attr, Invoker&& i) {
    400400        using state_impl = state<Invoker>;
    401         return state_ptr{ new state_impl (attr, std::forward<Invoker> (i)) };
     401        return state_ptr{ new state_impl(attr, std::forward<Invoker>(i)) };
    402402      }
    403403
     
    414414      template<typename F, typename... Args>
    415415      static invoker<decayed_tuple<F, Args...>>
    416       make_invoker (F&& func, Args&&... args)
     416      make_invoker(F&& func, Args&&... args)
    417417      {
    418418        return {
    419419          decayed_tuple<F, Args...> {
    420             std::forward<F> (func), std::forward<Args> (args)...
     420            std::forward<F>(func), std::forward<Args>(args)...
    421421          }
    422422        };
     
    426426       * Create and start the thread.
    427427       */
    428       void start_thread (state_ptr s);
     428      void start_thread(state_ptr s);
    429429    };
    430430
    431431    template <class T>
    432432    inline typename std::decay<T>::type
    433     decay_copy (T&& t) {
    434       return std::forward<T> (t);
     433    decay_copy(T&& t) {
     434      return std::forward<T>(t);
    435435    }
    436436
    437437    template<typename F, typename... Args>
    438     thread::thread (F&& func, Args&&... args)
    439       : id_ (0)  {
     438    thread::thread(F&& func, Args&&... args)
     439      : id_(0)  {
    440440      attributes attr;
    441       start_thread (
    442         make_state (attr,
    443                     make_invoker (decay_copy (std::forward<F> (func)),
    444                                   decay_copy (std::forward<Args> (args))...))
     441      start_thread(
     442        make_state(attr,
     443                   make_invoker(decay_copy(std::forward<F>(func)),
     444                                decay_copy(std::forward<Args>(args))...))
    445445      );
    446446    }
     
    448448    template<typename A, typename F, typename... Args,
    449449             class = thread::enable_if_attributes<A>>
    450     thread::thread (A&& attr, F&& func, Args&&... args)
    451       : id_ (0) {
    452       start_thread (
    453         make_state (attr,
    454                     make_invoker (decay_copy (std::forward<F> (func)),
    455                                   decay_copy (std::forward<Args> (args))...))
     450    thread::thread(A&& attr, F&& func, Args&&... args)
     451      : id_(0) {
     452      start_thread(
     453        make_state(attr,
     454                   make_invoker(decay_copy(std::forward<F>(func)),
     455                                decay_copy(std::forward<Args>(args))...))
    456456      );
    457457    }
    458458
    459459    inline std::thread::id thread::get_id() const noexcept {
    460       return std::thread::id (id_.id_);
     460      return std::thread::id(id_.id_);
    461461    }
    462462
    463463    inline bool
    464     operator== (thread::id l, thread::id r) noexcept {
     464    operator==(thread::id l, thread::id r) noexcept {
    465465      return l.id_ == r.id_;
    466466    }
    467467
    468468    inline bool
    469     operator!= (thread::id l, thread::id r) noexcept {
     469    operator!=(thread::id l, thread::id r) noexcept {
    470470      return !(l == r);
    471471    }
     
    473473    template<class C, class T>
    474474    inline std::basic_ostream<C, T>&
    475     operator<< (std::basic_ostream<C, T>& out, thread::id id_) {
    476       return out << std::thread::id (id_.id_);
     475    operator<<(std::basic_ostream<C, T>& out, thread::id id_) {
     476      return out << std::thread::id(id_.id_);
    477477    }
    478478  };
  • cpukit/librtemscxx/error.cpp

    r6f2a219f r89a22be  
    3030namespace rtems
    3131{
    32   runtime_error::runtime_error (const rtems_status_code sc)
    33     : std::runtime_error (::rtems_status_text (sc)),
    34       sc (sc)
     32  runtime_error::runtime_error(const rtems_status_code sc)
     33    : std::runtime_error(::rtems_status_text(sc)),
     34      sc(sc)
    3535  {
    3636  }
    3737
    38   runtime_error::runtime_error (const rtems_status_code sc,
    39                                 const std::string&      what)
    40     : std::runtime_error (what + ": " + ::rtems_status_text (sc)),
    41       sc (sc)
     38  runtime_error::runtime_error(const rtems_status_code sc,
     39                               const std::string&      what)
     40    : std::runtime_error(what + ": " + ::rtems_status_text(sc)),
     41      sc(sc)
    4242  {
    4343  }
    4444
    45   runtime_error::runtime_error (const rtems_status_code sc,
    46                                 const char*             what)
    47     : std::runtime_error (std::string (what) + ": " + ::rtems_status_text (sc)),
    48       sc (sc)
     45  runtime_error::runtime_error(const rtems_status_code sc,
     46                               const char*             what)
     47    : std::runtime_error(std::string(what) + ": " + ::rtems_status_text(sc)),
     48      sc(sc)
    4949  {
    5050  }
     
    5555
    5656  void
    57   runtime_error_check (const rtems_status_code sc)
     57  runtime_error_check(const rtems_status_code sc)
    5858  {
    5959    if (sc != RTEMS_SUCCESSFUL) {
    60       throw runtime_error (sc);
     60      throw runtime_error(sc);
    6161    }
    6262  }
    6363
    6464  void
    65   runtime_error_check (const rtems_status_code sc, const std::string& what)
     65  runtime_error_check(const rtems_status_code sc, const std::string& what)
    6666  {
    6767    if (sc != RTEMS_SUCCESSFUL) {
    68       throw runtime_error (sc, what);
     68      throw runtime_error(sc, what);
    6969    }
    7070  }
    7171
    7272  void
    73   runtime_error_check (const rtems_status_code sc, const char* what)
     73  runtime_error_check(const rtems_status_code sc, const char* what)
    7474  {
    7575    if (sc != RTEMS_SUCCESSFUL) {
    76       throw runtime_error (sc, what);
     76      throw runtime_error(sc, what);
    7777    }
    7878  }
  • cpukit/librtemscxx/thread.cpp

    r6f2a219f r89a22be  
    4040
    4141#if HAVE_GET_SCHEDULER_NAME
    42 extern "C" bool get_scheduler_name (rtems_id sid, char* name);
     42extern "C" bool get_scheduler_name(rtems_id sid, char* name);
    4343#endif
    4444
    4545#if HAVE_GET_SCHEDULER_NAME
    46 bool get_scheduler_name (rtems_id sid, char* name)
     46bool get_scheduler_name(rtems_id sid, char* name)
    4747{
    4848  name[0] = 'N';
     
    5959  {
    6060    void
    61     system_error_check (int ec, const char* what)
     61    system_error_check(int ec, const char* what)
    6262    {
    6363      if (ec != 0) {
    64         throw std::system_error (ec, std::system_category(), what);
    65       }
    66     }
    67 
    68     attributes::attributes ()
    69       : priority (-1),
    70         stack_size (RTEMS_MINIMUM_STACK_SIZE),
    71         attr (sched_inherit),
    72         policy (sched_fifo)
    73     {
    74       update ();
    75     }
    76 
    77     attributes::attributes (const attributes& attr)
    78       : name (attr.name),
    79         priority (attr.priority),
    80         stack_size (attr.stack_size),
    81         scheduler (attr.scheduler),
    82         attr (attr.attr),
    83         policy (attr.policy)
    84     {
    85     }
    86 
    87     void
    88     attributes::set_name (const std::string& name_)
     64        throw std::system_error(ec, std::system_category(), what);
     65      }
     66    }
     67
     68    attributes::attributes()
     69      : priority(-1),
     70        stack_size(RTEMS_MINIMUM_STACK_SIZE),
     71        attr(sched_inherit),
     72        policy(sched_fifo)
     73    {
     74      update();
     75    }
     76
     77    attributes::attributes(const attributes& attr)
     78      : name(attr.name),
     79        priority(attr.priority),
     80        stack_size(attr.stack_size),
     81        scheduler(attr.scheduler),
     82        attr(attr.attr),
     83        policy(attr.policy)
     84    {
     85    }
     86
     87    void
     88    attributes::set_name(const std::string& name_)
    8989    {
    9090      name = name_;
     
    9292
    9393    void
    94     attributes::set_name (const char* name_)
     94    attributes::set_name(const char* name_)
    9595    {
    9696      name = name_;
     
    9898
    9999    const std::string&
    100     attributes::get_name () const
     100    attributes::get_name() const
    101101    {
    102102      return name;
     
    104104
    105105    void
    106     attributes::set_priority (int priority_)
     106    attributes::set_priority(int priority_)
    107107    {
    108108      priority = priority_;
     
    110110
    111111    int
    112     attributes::get_priority () const
     112    attributes::get_priority() const
    113113    {
    114114      return priority;
     
    122122
    123123    size_t
    124     attributes::get_stack_size () const
     124    attributes::get_stack_size() const
    125125    {
    126126      return stack_size;
     
    128128
    129129    void
    130     attributes::set_scheduler (const std::string& scheduler_)
     130    attributes::set_scheduler(const std::string& scheduler_)
    131131    {
    132132      scheduler = scheduler_;
     
    134134
    135135    void
    136     attributes::set_scheduler (const char* scheduler_)
     136    attributes::set_scheduler(const char* scheduler_)
    137137    {
    138138      scheduler = scheduler_;
     
    140140
    141141    const std::string&
    142     attributes::get_scheduler ()
     142    attributes::get_scheduler()
    143143    {
    144144      return scheduler;
     
    146146
    147147    attributes::sched_attr
    148     attributes::get_scheduler_attr () const
     148    attributes::get_scheduler_attr() const
    149149    {
    150150      return attr;
     
    152152
    153153    void
    154     attributes::set_scheduler_policy (sched_policy policy_)
     154    attributes::set_scheduler_policy(sched_policy policy_)
    155155    {
    156156      attr = sched_explicit;
     
    159159
    160160    attributes::sched_policy
    161     attributes::get_scheduler_policy () const
     161    attributes::get_scheduler_policy() const
    162162    {
    163163      return policy;
     
    165165
    166166    void
    167     attributes::commit ()
    168     {
    169       pthread_t pid = ::pthread_self ();
    170 
    171       system_error_check (::pthread_setname_np (pid, name.c_str ()),
    172                           "getting name");
     167    attributes::commit()
     168    {
     169      pthread_t pid = ::pthread_self();
     170
     171      system_error_check(::pthread_setname_np(pid, name.c_str()),
     172                         "getting name");
    173173
    174174      int                spolicy;
    175175      struct sched_param sched_param;
    176176
    177       system_error_check (::pthread_getschedparam (::pthread_self (),
    178                                                    &spolicy,
    179                                                    &sched_param),
    180                           "getting scheduler parameters");
     177      system_error_check(::pthread_getschedparam(::pthread_self(),
     178                                                 &spolicy,
     179                                                 &sched_param),
     180                         "getting scheduler parameters");
    181181
    182182      switch (policy) {
     
    194194        break;
    195195      default:
    196         system_error_check (EINVAL, "get scheduler policy");
     196        system_error_check(EINVAL, "get scheduler policy");
    197197        break;
    198198      }
     
    200200      sched_param.sched_priority = priority;
    201201
    202       system_error_check (::pthread_setschedparam (::pthread_self (),
    203                                                    spolicy,
    204                                                    &sched_param),
    205                           "getting scheduler parameters");
    206 
    207       if (!scheduler.empty ()) {
     202      system_error_check(::pthread_setschedparam(::pthread_self(),
     203                                                 spolicy,
     204                                                 &sched_param),
     205                         "getting scheduler parameters");
     206
     207      if (!scheduler.empty()) {
    208208        char sname[4] = { ' ', ' ', ' ', ' ' };
    209         for (size_t c = 0; c < sizeof (sname); ++c) {
    210           if (c >= scheduler.length ()) {
     209        for (size_t c = 0; c < sizeof(sname); ++c) {
     210          if (c >= scheduler.length()) {
    211211            break;
    212212          }
    213213          sname[c] = scheduler[c];
    214214        }
    215         rtems_name scheduler_name = rtems_build_name (sname[0],
    216                                                       sname[1],
    217                                                       sname[2],
    218                                                       sname[3]);
     215        rtems_name scheduler_name = rtems_build_name(sname[0],
     216                                                     sname[1],
     217                                                     sname[2],
     218                                                     sname[3]);
    219219        rtems_id scheduler_id;
    220         runtime_error_check (::rtems_scheduler_ident (scheduler_name,
    221                                                       &scheduler_id),
    222                              "get scheduler id");
     220        runtime_error_check(::rtems_scheduler_ident(scheduler_name,
     221                                                    &scheduler_id),
     222                            "get scheduler id");
    223223        // runtime_error_check (::rtems_task_set_scheduler (RTEMS_SELF,
    224224        //                                                  scheduler_id,
     
    229229
    230230    void
    231     attributes::update ()
     231    attributes::update()
    232232    {
    233233      char buf[32];
    234       system_error_check (::pthread_getname_np (::pthread_self (),
    235                                                 buf,
    236                                                 sizeof (buf)),
    237                           "getting name");
     234      system_error_check(::pthread_getname_np(::pthread_self(),
     235                                              buf,
     236                                              sizeof (buf)),
     237                         "getting name");
    238238      name = buf;
    239239
    240240      int                spolicy;
    241241      struct sched_param sched_param;
    242       system_error_check (::pthread_getschedparam (::pthread_self (),
    243                                                    &spolicy,
    244                                                    &sched_param),
    245                           "getting scheduler parameters");
     242      system_error_check(::pthread_getschedparam(::pthread_self(),
     243                                                 &spolicy,
     244                                                 &sched_param),
     245                         "getting scheduler parameters");
    246246
    247247      switch (spolicy) {
     
    259259        break;
    260260      default:
    261         system_error_check (EINVAL, "get scheduler policy");
     261        system_error_check(EINVAL, "get scheduler policy");
    262262        break;
    263263      }
     
    265265
    266266      pthread_attr_t pattr;
    267       system_error_check (::pthread_getattr_np (::pthread_self (), &pattr),
    268                           "getting thread attributes");
    269       system_error_check (::pthread_attr_getstacksize (&pattr, &stack_size),
    270                           "getting stack size");
     267      system_error_check(::pthread_getattr_np(::pthread_self(), &pattr),
     268                         "getting thread attributes");
     269      system_error_check(::pthread_attr_getstacksize(&pattr, &stack_size),
     270                         "getting stack size");
    271271      int inheritsched = 0;
    272       system_error_check (::pthread_attr_getinheritsched (&pattr, &inheritsched),
    273                           "getting inherited sheduler attribute");
     272      system_error_check(::pthread_attr_getinheritsched(&pattr, &inheritsched),
     273                         "getting inherited sheduler attribute");
    274274      switch (inheritsched) {
    275275      case PTHREAD_INHERIT_SCHED:
     
    280280        break;
    281281      default:
    282         system_error_check (EINVAL, "get scheduler attribute");
     282        system_error_check(EINVAL, "get scheduler attribute");
    283283        break;
    284284      }
    285285
    286286      rtems_id scheduler_id;
    287       runtime_error_check (::rtems_task_get_scheduler (RTEMS_SELF, &scheduler_id));
     287      runtime_error_check(::rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id));
    288288#if HAVE_GET_SCHEDULER_NAME
    289289      char name[5];
    290       if (!get_scheduler_name (scheduler_id, &name[0])) {
    291         system_error_check (ENOENT, "get scheduler name");
     290      if (!get_scheduler_name(scheduler_id, &name[0])) {
     291        system_error_check(ENOENT, "get scheduler name");
    292292      }
    293293      scheduler = name;
     
    296296
    297297    attributes&
    298     attributes::operator= (const attributes& other)
     298    attributes::operator=(const attributes& other)
    299299    {
    300300      name = other.name;
     
    307307
    308308    bool
    309     attributes::operator== (const attributes& other) const
     309    attributes::operator==(const attributes& other) const
    310310    {
    311311      return
     
    318318
    319319    void*
    320     thread_generic_entry (void* arg)
    321     {
    322       thread::state_ptr s{ static_cast<thread::state_base*> (arg) };
     320    thread_generic_entry(void* arg)
     321    {
     322      thread::state_ptr s{ static_cast<thread::state_base*>(arg) };
    323323      try {
    324         s->run ();
     324        s->run();
    325325      } catch (...) {
    326         std::terminate ();
     326        std::terminate();
    327327      }
    328328      return nullptr;
     
    330330
    331331    thread&
    332     thread::operator= (thread&& thread_)
    333     {
    334       if (joinable ()) {
    335         std::terminate ();
     332    thread::operator=(thread&& thread_)
     333    {
     334      if (joinable()) {
     335        std::terminate();
    336336      }
    337337      swap(thread_);
     
    355355    {
    356356      if (!joinable()) {
    357         system_error_check (EINVAL, "join");
    358       }
    359       system_error_check (::pthread_join (id_.id_, nullptr), "join");
     357        system_error_check(EINVAL, "join");
     358      }
     359      system_error_check(::pthread_join(id_.id_, nullptr), "join");
    360360      id_ = id();
    361361    }
     
    365365    {
    366366      if (!joinable()) {
    367         system_error_check (EINVAL, "detach");
    368       }
    369       system_error_check (::pthread_detach (id_.id_), "detach");
     367        system_error_check(EINVAL, "detach");
     368      }
     369      system_error_check(::pthread_detach(id_.id_), "detach");
    370370      id_ = id();
    371371    }
    372372
    373     thread::state_base::~state_base () = default;
    374 
    375     void
    376     thread::start_thread (thread::state_ptr s)
    377     {
    378       const attributes attr = s->get_attributes ();
     373    thread::state_base::~state_base() = default;
     374
     375    void
     376    thread::start_thread(thread::state_ptr s)
     377    {
     378      const attributes attr = s->get_attributes();
    379379
    380380      pthread_attr_t pattr;
    381381
    382       system_error_check (::pthread_attr_init (&pattr),
    383                           "attribute init");
     382      system_error_check(::pthread_attr_init(&pattr),
     383                         "attribute init");
    384384
    385385      struct sched_param param;
    386       param.sched_priority = attr.get_priority ();
    387       system_error_check (::pthread_attr_setschedparam (&pattr, &param),
    388                           "set sched param");
     386      param.sched_priority = attr.get_priority();
     387      system_error_check(::pthread_attr_setschedparam(&pattr, &param),
     388                         "set sched param");
    389389
    390390      int spolicy;
    391       switch (attr.get_scheduler_policy ()) {
     391      switch (attr.get_scheduler_policy()) {
    392392      case attributes::sched_other:
    393393        spolicy = SCHED_OTHER;
     
    403403        break;
    404404      }
    405       system_error_check (::pthread_attr_setschedpolicy (&pattr, spolicy),
    406                           "set scheduler policy");
    407 
    408       if (attr.get_scheduler_attr () == attributes::sched_inherit) {
    409         ::pthread_attr_setinheritsched (&pattr, PTHREAD_INHERIT_SCHED);
     405      system_error_check(::pthread_attr_setschedpolicy(&pattr, spolicy),
     406                         "set scheduler policy");
     407
     408      if (attr.get_scheduler_attr() == attributes::sched_inherit) {
     409        ::pthread_attr_setinheritsched(&pattr, PTHREAD_INHERIT_SCHED);
    410410      }
    411411      else {
    412         ::pthread_attr_setinheritsched (&pattr, PTHREAD_EXPLICIT_SCHED);
    413       }
    414 
    415       system_error_check (::pthread_attr_setstacksize(&pattr,
    416                                                       attr.get_stack_size ()),
    417                           "set stack size");
     412        ::pthread_attr_setinheritsched(&pattr, PTHREAD_EXPLICIT_SCHED);
     413      }
     414
     415      system_error_check(::pthread_attr_setstacksize(&pattr,
     416                                                     attr.get_stack_size()),
     417                         "set stack size");
    418418
    419419      /*
     
    421421       * of the thread is set up after the create call.
    422422       */
    423       system_error_check (::pthread_create (&id_.id_,
    424                                             &pattr,
    425                                             thread_generic_entry,
    426                                             s.get ()),
    427                           "create thread");
    428 
    429       system_error_check (::pthread_setname_np (id_.id_,
    430                                                 attr.get_name ().c_str ()),
    431                           "setting thread name");
    432 
    433       ::pthread_attr_destroy (&pattr);
    434 
    435       s.release ();
     423      system_error_check(::pthread_create(&id_.id_,
     424                                          &pattr,
     425                                          thread_generic_entry,
     426                                          s.get()),
     427                         "create thread");
     428
     429      system_error_check(::pthread_setname_np(id_.id_,
     430                                              attr.get_name().c_str()),
     431                         "setting thread name");
     432
     433      ::pthread_attr_destroy(&pattr);
     434
     435      s.release();
    436436    };
    437437  };
Note: See TracChangeset for help on using the changeset viewer.