AuthFwd.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac
 
    This file is part of Leosac.
 
    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Leosac 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 Affero General Public License for more details.
 
    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cstddef>
#include <memory>
#include <odb/lazy-ptr.hxx>
 
namespace Leosac
{
namespace Auth
{
class User;
using UserPtr   = std::shared_ptr<User>;
using UserLPtr  = odb::lazy_shared_ptr<User>;
using UserLWPtr = odb::lazy_weak_ptr<User>;
using UserId    = unsigned long;
 
class Group;
using GroupPtr   = std::shared_ptr<Group>;
using GroupWPtr  = std::weak_ptr<Group>;
using GroupLWPtr = odb::lazy_weak_ptr<Group>;
using GroupLPtr  = odb::lazy_shared_ptr<Group>;
using GroupId    = unsigned long;
 
class SimpleAccessProfile;
using SimpleAccessProfilePtr = std::shared_ptr<SimpleAccessProfile>;
 
enum class GroupRank
{
    MEMBER   = 0,
    OPERATOR = 1,
    ADMIN    = 2,
};
 
enum class UserRank
{
    USER = 0,
    VIEWER = 1,
    MANAGER = 2,
    SUPERVISOR = 3,
    ADMIN = 4,
};
 
class UserGroupMembership;
using UserGroupMembershipPtr = std::shared_ptr<UserGroupMembership>;
using UserGroupMembershipId  = unsigned long;
 
class Token;
using TokenPtr = std::shared_ptr<Token>;
 
class IAccessProfile;
using IAccessProfilePtr = std::shared_ptr<IAccessProfile>;
 
class ValidityInfo;
 
class AuthTarget;
using AuthTargetPtr = std::shared_ptr<AuthTarget>;
 
class IAuthenticationSource;
using IAuthenticationSourcePtr = std::shared_ptr<IAuthenticationSource>;
 
class BaseAuthSource;
using BaseAuthSourcePtr = std::shared_ptr<BaseAuthSource>;
 
class WiegandCard;
 
class IDoor;
using IDoorPtr   = std::shared_ptr<IDoor>;
using IDoorLPtr  = odb::lazy_shared_ptr<IDoor>;
using IDoorLWPtr = odb::lazy_weak_ptr<IDoor>;
using DoorId     = unsigned long;
 
class Door;
using DoorLWPtr = odb::lazy_weak_ptr<Door>;
using DoorLPtr  = odb::lazy_shared_ptr<Door>;
using DoorPtr   = std::shared_ptr<Door>;
 
 
class IZone;
using IZonePtr   = std::shared_ptr<IZone>;
using IZoneLPtr  = odb::lazy_shared_ptr<IZone>;
using IZoneLWPtr = odb::lazy_weak_ptr<IZone>;
using ZoneId     = unsigned long;
 
class Zone;
using ZoneLWPtr = odb::lazy_weak_ptr<Zone>;
using ZoneLPtr  = odb::lazy_shared_ptr<Zone>;
using ZonePtr   = std::shared_ptr<Zone>;
 
class IAccessPoint;
using IAccessPointPtr = std::shared_ptr<IAccessPoint>;
using AccessPointId   = unsigned long;
 
class AccessPoint;
using AccessPointLWPtr = odb::lazy_weak_ptr<AccessPoint>;
using AccessPointLPtr  = odb::lazy_shared_ptr<AccessPoint>;
using AccessPointPtr   = std::shared_ptr<AccessPoint>;
 
class AccessPointUpdate;
using AccessPointUpdatePtr  = std::shared_ptr<AccessPointUpdate>;
using AccessPointUpdateLPtr = odb::lazy_shared_ptr<AccessPointUpdate>;
}
}