Permissions.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_Permissions_hxx
#define __ccxx_Permissions_hxx

#include <commonc++/Common.h++>
#include <commonc++/String.h++>

namespace ccxx {

class COMMONCPP_API Permissions
{
 public:

  Permissions(uint_t mask = 0);

  Permissions(const Permissions& other);

  ~Permissions();

  static const int USER_READ;

  static const int USER_WRITE;

  static const int USER_READ_WRITE;

  static const int USER_EXECUTE;

  static const int USER_ALL;

  static const int GROUP_READ;

  static const int GROUP_WRITE;

  static const int GROUP_READ_WRITE;

  static const int GROUP_EXECUTE;

  static const int GROUP_ALL;

  static const int OTHERS_READ;

  static const int OTHERS_WRITE;

  static const int OTHERS_READ_WRITE;

  static const int OTHERS_EXECUTE;

  static const int OTHERS_ALL;

  static const int ALL_READ_WRITE;

  static const int ALLBITS;

  // user

  inline bool canUserRead() const
  { return((_mask & USER_READ) != 0); }

  inline void setUserRead()
  { _mask |= USER_READ; }

  inline void clearUserRead()
  { _mask &= ~USER_READ; }

  inline bool canUserWrite() const
  { return((_mask & USER_WRITE) != 0); }

  inline void setUserWrite()
  { _mask |= USER_WRITE; }

  inline void clearUserWrite()
  { _mask &= ~USER_WRITE; }

  inline bool canUserExecute() const
  { return((_mask & USER_EXECUTE) != 0); }

  inline void setUserExecute()
  { _mask |= USER_EXECUTE; }

  inline void clearUserExecute()
  { _mask &= ~USER_EXECUTE; }

  // group

  inline bool canGroupRead() const
  { return((_mask & GROUP_READ) != 0); }

  inline void setGroupRead()
  { _mask |= GROUP_READ; }

  inline void clearGroupRead()
  { _mask &= ~GROUP_READ; }

  inline bool canGroupWrite() const
  { return((_mask & GROUP_WRITE) != 0); }

  inline void setGroupWrite()
  { _mask |= GROUP_WRITE; }

  inline void clearGroupWrite()
  { _mask &= ~GROUP_WRITE; }

  inline bool canGroupExecute() const
  { return((_mask & GROUP_EXECUTE) != 0); }

  inline void setGroupExecute()
  { _mask |= GROUP_EXECUTE; }

  inline void clearGroupExecute()
  { _mask &= ~GROUP_EXECUTE; }

  // others

  inline bool canOthersRead() const
  { return((_mask & OTHERS_READ) != 0); }

  inline void setOthersRead()
  { _mask |= OTHERS_READ; }

  inline void clearOthersRead()
  { _mask &= ~OTHERS_READ; }

  inline bool canOthersWrite() const
  { return((_mask & OTHERS_WRITE) != 0); }

  inline void setOthersWrite()
  { _mask |= OTHERS_WRITE; }

  inline void clearOthersWrite()
  { _mask &= ~OTHERS_WRITE; }

  inline bool canOthersExecute() const
  { return((_mask & OTHERS_EXECUTE) != 0); }

  inline void setOthersExecute()
  { _mask |= OTHERS_EXECUTE; }

  inline void clearOthersExecute()
  { _mask &= ~OTHERS_EXECUTE; }

  inline void clearAll()
  { _mask = 0; }

  // operators

  Permissions& operator=(const Permissions& other);

  inline uint_t getMask() const
  { return(_mask); }

  inline operator uint_t()
  { return(_mask); }

  String toString() const;

  inline uint_t operator=(uint_t rhs)
  { return((_mask = rhs)); }

  inline uint_t operator|=(uint_t rhs)
  { return(_mask |= (rhs & ALLBITS)); }

  inline uint_t operator&=(uint_t rhs)
  { return(_mask &= (rhs & ALLBITS)); }

  static const Permissions defaultFilePerms;

  static const Permissions defaultDirPerms;

 private:

  uint_t _mask;
};

inline uint_t operator|(const Permissions& perm, const uint_t rhs)
{ return(perm.getMask() | (rhs & Permissions::ALLBITS)); }

inline uint_t operator&(const Permissions& perm, const uint_t rhs)
{ return(perm.getMask() & (rhs & Permissions::ALLBITS)); }

} // namespace ccxx

#endif // __ccxx_Permissions_hxx