fix indentation

Foundation/include/Poco/Thread.h

@@ -46,68 +46,68 @@ class ThreadLocalStorage;
 
 
 class Foundation_API Thread: private ThreadImpl
-  /// This class implements a platform-independent
-  /// wrapper to an operating system thread.
-  ///
-  /// Every Thread object gets a unique (within
-  /// its process) numeric thread ID.
-  /// Furthermore, a thread can be assigned a name.
-  /// The name of a thread can be changed at any time.
+/// This class implements a platform-independent
+/// wrapper to an operating system thread.
+///
+/// Every Thread object gets a unique (within
+/// its process) numeric thread ID.
+/// Furthermore, a thread can be assigned a name.
+/// The name of a thread can be changed at any time.
 {
 public:
-  typedef ThreadImpl::TIDImpl TID;
+    typedef ThreadImpl::TIDImpl TID;
 
-  using ThreadImpl::Callable;
+    using ThreadImpl::Callable;
 
-  enum Priority
+    enum Priority
     /// Thread priorities.
-  {
-    PRIO_LOWEST  = PRIO_LOWEST_IMPL, /// The lowest thread priority.
-    PRIO_LOW     = PRIO_LOW_IMPL,    /// A lower than normal thread priority.
-    PRIO_NORMAL  = PRIO_NORMAL_IMPL, /// The normal thread priority.
-    PRIO_HIGH    = PRIO_HIGH_IMPL,   /// A higher than normal thread priority.
-    PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority.
-  };
+    {
+        PRIO_LOWEST  = PRIO_LOWEST_IMPL, /// The lowest thread priority.
+        PRIO_LOW     = PRIO_LOW_IMPL,    /// A lower than normal thread priority.
+        PRIO_NORMAL  = PRIO_NORMAL_IMPL, /// The normal thread priority.
+        PRIO_HIGH    = PRIO_HIGH_IMPL,   /// A higher than normal thread priority.
+        PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority.
+    };
 
-  enum Policy
-  {
-    POLICY_DEFAULT = POLICY_DEFAULT_IMPL
-  };
+    enum Policy
+    {
+        POLICY_DEFAULT = POLICY_DEFAULT_IMPL
+    };
 
-  Thread();
+    Thread();
     /// Creates a thread. Call start() to start it.
 
-  Thread(const std::string& name);
+    Thread(const std::string& name);
     /// Creates a named thread. Call start() to start it.
 
-  ~Thread();
+    ~Thread();
     /// Destroys the thread.
 
-  int id() const;
+    int id() const;
     /// Returns the unique thread ID of the thread.
 
-  TID tid() const;
+    TID tid() const;
     /// Returns the native thread ID of the thread.
 
-  std::string name() const;
+    std::string name() const;
     /// Returns the name of the thread.
 
-  std::string getName() const;
+    std::string getName() const;
     /// Returns the name of the thread.
 
-  void setName(const std::string& name);
+    void setName(const std::string& name);
     /// Sets the name of the thread.
 
-  void setPriority(Priority prio);
+    void setPriority(Priority prio);
     /// Sets the thread's priority.
     ///
     /// Some platform only allow changing a thread's priority
     /// if the process has certain privileges.
 
-  Priority getPriority() const;
+    Priority getPriority() const;
     /// Returns the thread's priority.
 
-  void setOSPriority(int prio, int policy = POLICY_DEFAULT);
+    void setOSPriority(int prio, int policy = POLICY_DEFAULT);
     /// Sets the thread's priority, using an operating system specific
     /// priority value. Use getMinOSPriority() and getMaxOSPriority() to
     /// obtain mininum and maximum priority values. Additionally,
@@ -115,74 +115,74 @@ public:
     /// only used on POSIX platforms where the values SCHED_OTHER (default),
     /// SCHED_FIFO and SCHED_RR are supported.
 
-  int getOSPriority() const;
+    int getOSPriority() const;
     /// Returns the thread's priority, expressed as an operating system
     /// specific priority value.
     ///
     /// May return 0 if the priority has not been explicitly set.
 
-  static int getMinOSPriority(int policy = POLICY_DEFAULT);
+    static int getMinOSPriority(int policy = POLICY_DEFAULT);
     /// Returns the minimum operating system-specific priority value,
     /// which can be passed to setOSPriority() for the given policy.
 
-  static int getMaxOSPriority(int policy = POLICY_DEFAULT);
+    static int getMaxOSPriority(int policy = POLICY_DEFAULT);
     /// Returns the maximum operating system-specific priority value,
     /// which can be passed to setOSPriority() for the given policy.
 
-  void setStackSize(int size);
+    void setStackSize(int size);
     /// Sets the thread's stack size in bytes.
     /// Setting the stack size to 0 will use the default stack size.
     /// Typically, the real stack size is rounded up to the nearest
     /// page size multiple.
 
-  void setAffinity(unsigned int cpu);
+    void setAffinity(unsigned int cpu);
     /// Limit specified thread to run only on the processors "cpu"
     /// cpu - processor (core) number
     /// Method would Throw SystemException if affinity did not setted
 
-  unsigned getAffinity() const;
+    unsigned getAffinity() const;
     /// Returns using cpu (core) number
 
-  int getStackSize() const;
+    int getStackSize() const;
     /// Returns the thread's stack size in bytes.
     /// If the default stack size is used, 0 is returned.
 
-  void start(Runnable& target);
+    void start(Runnable& target);
     /// Starts the thread with the given target.
     ///
     /// Note that the given Runnable object must remain
     /// valid during the entire lifetime of the thread, as
     /// only a reference to it is stored internally.
 
-  void start(Callable target, void* pData = 0);
+    void start(Callable target, void* pData = 0);
     /// Starts the thread with the given target and parameter.
 
-  template <class Functor>
-  void startFunc(Functor fn)
+    template <class Functor>
+    void startFunc(Functor fn)
     /// Starts the thread with the given functor object or lambda.
-  {
-    startImpl(new FunctorRunnable<Functor>(fn));
-  }
+    {
+        startImpl(new FunctorRunnable<Functor>(fn));
+    }
 
-  void join();
+    void join();
     /// Waits until the thread completes execution.
     /// If multiple threads try to join the same
     /// thread, the result is undefined.
 
-  void join(long milliseconds);
+    void join(long milliseconds);
     /// Waits for at most the given interval for the thread
     /// to complete. Throws a TimeoutException if the thread
     /// does not complete within the specified time interval.
 
-  bool tryJoin(long milliseconds);
+    bool tryJoin(long milliseconds);
     /// Waits for at most the given interval for the thread
     /// to complete. Returns true if the thread has finished,
     /// false otherwise.
 
-  bool isRunning() const;
+    bool isRunning() const;
     /// Returns true if the thread is running.
 
-  static bool trySleep(long milliseconds);
+    static bool trySleep(long milliseconds);
     /// Starts an interruptible sleep. When trySleep() is called,
     /// the thread will remain suspended until:
     ///   - the timeout expires or
@@ -204,73 +204,73 @@ public:
     /// trySleep() call to actually suspend the thread (which, in
     /// some scenarios, may be desirable behavior).
 
-  void wakeUp();
+    void wakeUp();
     /// Wakes up the thread which is in the state of interruptible
     /// sleep. For threads that are not suspended, calling this
     /// function has the effect of preventing the subsequent
     /// trySleep() call to put thread in a suspended state.
 
-  static void sleep(long milliseconds);
+    static void sleep(long milliseconds);
     /// Suspends the current thread for the specified
     /// amount of time.
 
-  static void yield();
+    static void yield();
     /// Yields cpu to other threads.
 
-  static Thread* current();
+    static Thread* current();
     /// Returns the Thread object for the currently active thread.
     /// If the current thread is the main thread, 0 is returned.
 
-  static TID currentTid();
+    static TID currentTid();
     /// Returns the native thread ID for the current thread.
 
 protected:
-  ThreadLocalStorage& tls();
+    ThreadLocalStorage& tls();
     /// Returns a reference to the thread's local storage.
 
-  void clearTLS();
+    void clearTLS();
     /// Clears the thread's local storage.
 
-  std::string makeName();
+    std::string makeName();
     /// Creates a unique name for a thread.
 
-  static int uniqueId();
+    static int uniqueId();
     /// Creates and returns a unique id for a thread.
 
-  template <class Functor>
-  class FunctorRunnable: public Runnable
-  {
-  public:
-    FunctorRunnable(const Functor& functor):
-      _functor(functor)
+    template <class Functor>
+    class FunctorRunnable: public Runnable
     {
-    }
+    public:
+        FunctorRunnable(const Functor& functor):
+            _functor(functor)
+        {
+        }
 
-    ~FunctorRunnable()
-    {
-    }
+        ~FunctorRunnable()
+        {
+        }
 
-    void run()
-    {
-      _functor();
-    }
+        void run()
+        {
+            _functor();
+        }
 
-  private:
-    Functor _functor;
-  };
+    private:
+        Functor _functor;
+    };
 
 private:
-  Thread(const Thread&);
-  Thread& operator = (const Thread&);
+    Thread(const Thread&);
+    Thread& operator = (const Thread&);
 
-  int                 _id;
-  std::string         _name;
-  ThreadLocalStorage* _pTLS;
-  Event               _event;
-  mutable FastMutex   _mutex;
+    int                 _id;
+    std::string         _name;
+    ThreadLocalStorage* _pTLS;
+    Event               _event;
+    mutable FastMutex   _mutex;
 
-  friend class ThreadLocalStorage;
-  friend class PooledThread;
+    friend class ThreadLocalStorage;
+    friend class PooledThread;
 };
 
 
@@ -279,104 +279,104 @@ private:
 //
 inline Thread::TID Thread::tid() const
 {
-  return tidImpl();
+    return tidImpl();
 }
 
 
 inline int Thread::id() const
 {
-  return _id;
+    return _id;
 }
 
 
 inline std::string Thread::name() const
 {
-  FastMutex::ScopedLock lock(_mutex);
+    FastMutex::ScopedLock lock(_mutex);
 
-  return _name;
+    return _name;
 }
 
 
 inline std::string Thread::getName() const
 {
-  FastMutex::ScopedLock lock(_mutex);
+    FastMutex::ScopedLock lock(_mutex);
 
-  return _name;
+    return _name;
 }
 
 
 inline bool Thread::isRunning() const
 {
-  return isRunningImpl();
+    return isRunningImpl();
 }
 
 
 inline void Thread::sleep(long milliseconds)
 {
-  sleepImpl(milliseconds);
+    sleepImpl(milliseconds);
 }
 
 
 inline void Thread::yield()
 {
-  yieldImpl();
+    yieldImpl();
 }
 
 
 inline Thread* Thread::current()
 {
-  return static_cast<Thread*>(currentImpl());
+    return static_cast<Thread*>(currentImpl());
 }
 
 
 inline void Thread::setOSPriority(int prio, int policy)
 {
-  setOSPriorityImpl(prio, policy);
+    setOSPriorityImpl(prio, policy);
 }
 
 
 inline int Thread::getOSPriority() const
 {
-  return getOSPriorityImpl();
+    return getOSPriorityImpl();
 }
 
 
 inline int Thread::getMinOSPriority(int policy)
 {
-  return ThreadImpl::getMinOSPriorityImpl(policy);
+    return ThreadImpl::getMinOSPriorityImpl(policy);
 }
 
 
 inline int Thread::getMaxOSPriority(int policy)
 {
-  return ThreadImpl::getMaxOSPriorityImpl(policy);
+    return ThreadImpl::getMaxOSPriorityImpl(policy);
 }
 
 
 inline void Thread::setStackSize(int size)
 {
-  setStackSizeImpl(size);
+    setStackSizeImpl(size);
 }
 
-inline void Thread::setAffinity(unsigned int cpu) 
+inline void Thread::setAffinity(unsigned int cpu)
 {
-  setAffinityImpl(cpu);
+    setAffinityImpl(cpu);
 }
 
 inline unsigned Thread::getAffinity() const
 {
-  return getAffinityImpl();
+    return getAffinityImpl();
 }
 
 inline int Thread::getStackSize() const
 {
-  return getStackSizeImpl();
+    return getStackSizeImpl();
 }
 
 
 inline Thread::TID Thread::currentTid()
 {
-  return currentTidImpl();
+    return currentTidImpl();
 }