Permissions.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  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) throw();

  Permissions(const Permissions& other) throw();

  ~Permissions() throw();

  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 throw()
  { return((_mask & USER_READ) != 0); }

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

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

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

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

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

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

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

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

  // group

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

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

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

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

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

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

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

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

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

  // others

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

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

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

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

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

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

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

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

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

  inline void clearAll() throw()
  { _mask = 0; }

  // operators

  Permissions& operator=(const Permissions& other) throw();

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

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

  String toString() const;

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

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

  inline uint_t operator&=(uint_t rhs) throw()
  { 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) throw()
{ return(perm.getMask() | (rhs & Permissions::ALLBITS)); }

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

}; // namespace ccxx

#endif // __ccxx_Permissions_hxx

/* end of header file */