nr-ccm-rrc-sap.h

// Copyright (c) 2015 Danilo Abrignani
//
// SPDX-License-Identifier: GPL-2.0-only
//
// Author: Danilo Abrignani <danilo.abrignani@unibo.it>
 
#ifndef NR_CCM_RRC_SAP_H
#define NR_CCM_RRC_SAP_H
 
#include "nr-eps-bearer.h"
#include "nr-gnb-cmac-sap.h"
#include "nr-mac-sap.h"
#include "nr-rrc-sap.h"
 
#include <map>
 
namespace ns3
{
class NrUeCmacSapProvider;
class NrUeManager;
class NrGnbCmacSapProvider;
class NrMacSapUser;
class NrRrcSap;
 
class NrCcmRrcSapProvider
{
    friend class NrUeManager;
    friend class NrMacSapUser;
 
  public:
    virtual ~NrCcmRrcSapProvider() = default;
 
    struct LcsConfig
    {
        uint16_t componentCarrierId;     
        NrGnbCmacSapProvider::LcInfo lc; 
        NrMacSapUser* msu;               
    };
 
    virtual void ReportUeMeas(uint16_t rnti, NrRrcSap::MeasResults measResults) = 0;
 
    virtual void AddUe(uint16_t rnti, uint8_t state) = 0;
 
    virtual void AddLc(NrGnbCmacSapProvider::LcInfo lcInfo, NrMacSapUser* msu) = 0;
 
    virtual void RemoveUe(uint16_t rnti) = 0;
 
    virtual std::vector<NrCcmRrcSapProvider::LcsConfig> SetupDataRadioBearer(NrEpsBearer bearer,
                                                                             uint8_t bearerId,
                                                                             uint16_t rnti,
                                                                             uint8_t lcid,
                                                                             uint8_t lcGroup,
                                                                             NrMacSapUser* msu) = 0;
 
    virtual std::vector<uint8_t> ReleaseDataRadioBearer(uint16_t rnti, uint8_t lcid) = 0;
 
    virtual NrMacSapUser* ConfigureSignalBearer(NrGnbCmacSapProvider::LcInfo lcInfo,
                                                NrMacSapUser* rlcMacSapUser) = 0;
 
}; // end of class NrCcmRrcSapProvider
 
class NrCcmRrcSapUser
{
    friend class NrGnbRrc;
 
  public:
    virtual ~NrCcmRrcSapUser() = default;
 
    virtual uint8_t AddUeMeasReportConfigForComponentCarrier(
        NrRrcSap::ReportConfigEutra reportConfig) = 0;
 
    virtual void TriggerComponentCarrier(uint16_t rnti, uint16_t targetCellId) = 0;
 
    virtual void AddLcs(std::vector<NrGnbRrcSapProvider::LogicalChannelConfig> lcConfig) = 0;
 
    virtual void ReleaseLcs(uint16_t rnti, uint8_t lcid) = 0;
 
    virtual Ptr<NrUeManager> GetUeManager(uint16_t rnti) = 0;
 
    virtual void SetNumberOfComponentCarriers(uint16_t noOfComponentCarriers) = 0;
 
}; // end of class NrCcmRrcSapUser
 
template <class C>
class MemberNrCcmRrcSapProvider : public NrCcmRrcSapProvider
{
  public:
    MemberNrCcmRrcSapProvider(C* owner);
 
    // inherited from NrCcmRrcSapProvider
    void ReportUeMeas(uint16_t rnti, NrRrcSap::MeasResults measResults) override;
    void AddUe(uint16_t rnti, uint8_t state) override;
    void AddLc(NrGnbCmacSapProvider::LcInfo lcInfo, NrMacSapUser* msu) override;
    void RemoveUe(uint16_t rnti) override;
    std::vector<NrCcmRrcSapProvider::LcsConfig> SetupDataRadioBearer(NrEpsBearer bearer,
                                                                     uint8_t bearerId,
                                                                     uint16_t rnti,
                                                                     uint8_t lcid,
                                                                     uint8_t lcGroup,
                                                                     NrMacSapUser* msu) override;
    std::vector<uint8_t> ReleaseDataRadioBearer(uint16_t rnti, uint8_t lcid) override;
    NrMacSapUser* ConfigureSignalBearer(NrGnbCmacSapProvider::LcInfo lcInfo,
                                        NrMacSapUser* rlcMacSapUser) override;
 
  private:
    C* m_owner; 
};
 
template <class C>
MemberNrCcmRrcSapProvider<C>::MemberNrCcmRrcSapProvider(C* owner)
    : m_owner(owner)
{
}
 
template <class C>
void
MemberNrCcmRrcSapProvider<C>::ReportUeMeas(uint16_t rnti, NrRrcSap::MeasResults measResults)
{
    m_owner->DoReportUeMeas(rnti, measResults);
}
 
template <class C>
void
MemberNrCcmRrcSapProvider<C>::AddUe(uint16_t rnti, uint8_t state)
{
    m_owner->DoAddUe(rnti, state);
}
 
template <class C>
void
MemberNrCcmRrcSapProvider<C>::AddLc(NrGnbCmacSapProvider::LcInfo lcInfo, NrMacSapUser* msu)
{
    m_owner->DoAddLc(lcInfo, msu);
}
 
template <class C>
void
MemberNrCcmRrcSapProvider<C>::RemoveUe(uint16_t rnti)
{
    m_owner->DoRemoveUe(rnti);
}
 
template <class C>
std::vector<NrCcmRrcSapProvider::LcsConfig>
MemberNrCcmRrcSapProvider<C>::SetupDataRadioBearer(NrEpsBearer bearer,
                                                   uint8_t bearerId,
                                                   uint16_t rnti,
                                                   uint8_t lcid,
                                                   uint8_t lcGroup,
                                                   NrMacSapUser* msu)
{
    return m_owner->DoSetupDataRadioBearer(bearer, bearerId, rnti, lcid, lcGroup, msu);
}
 
template <class C>
std::vector<uint8_t>
MemberNrCcmRrcSapProvider<C>::ReleaseDataRadioBearer(uint16_t rnti, uint8_t lcid)
{
    return m_owner->DoReleaseDataRadioBearer(rnti, lcid);
}
 
template <class C>
NrMacSapUser*
MemberNrCcmRrcSapProvider<C>::ConfigureSignalBearer(NrGnbCmacSapProvider::LcInfo lcInfo,
                                                    NrMacSapUser* rlcMacSapUser)
{
    return m_owner->DoConfigureSignalBearer(lcInfo, rlcMacSapUser);
}
 
template <class C>
class MemberNrCcmRrcSapUser : public NrCcmRrcSapUser
{
  public:
    MemberNrCcmRrcSapUser(C* owner);
 
    // inherited from NrCcmRrcSapUser
    void AddLcs(std::vector<NrGnbRrcSapProvider::LogicalChannelConfig> lcConfig) override;
    void ReleaseLcs(uint16_t rnti, uint8_t lcid) override;
    uint8_t AddUeMeasReportConfigForComponentCarrier(
        NrRrcSap::ReportConfigEutra reportConfig) override;
    void TriggerComponentCarrier(uint16_t rnti, uint16_t targetCellId) override;
    Ptr<NrUeManager> GetUeManager(uint16_t rnti) override;
    void SetNumberOfComponentCarriers(uint16_t noOfComponentCarriers) override;
 
  private:
    C* m_owner; 
};
 
template <class C>
MemberNrCcmRrcSapUser<C>::MemberNrCcmRrcSapUser(C* owner)
    : m_owner(owner)
{
}
 
template <class C>
void
MemberNrCcmRrcSapUser<C>::AddLcs(std::vector<NrGnbRrcSapProvider::LogicalChannelConfig> lcConfig)
{
    NS_FATAL_ERROR("Function should not be called because it is not implemented.");
    // m_owner->DoAddLcs (lcConfig);
}
 
template <class C>
void
MemberNrCcmRrcSapUser<C>::ReleaseLcs(uint16_t rnti, uint8_t lcid)
{
    NS_FATAL_ERROR("Function should not be called because it is not implemented.");
    // m_owner->DoReleaseLcs (rnti, lcid);
}
 
template <class C>
uint8_t
MemberNrCcmRrcSapUser<C>::AddUeMeasReportConfigForComponentCarrier(
    NrRrcSap::ReportConfigEutra reportConfig)
{
    return m_owner->DoAddUeMeasReportConfigForComponentCarrier(reportConfig);
}
 
template <class C>
void
MemberNrCcmRrcSapUser<C>::TriggerComponentCarrier(uint16_t rnti, uint16_t targetCellId)
{
    NS_FATAL_ERROR("Function should not be called because it is not implemented.");
}
 
template <class C>
Ptr<NrUeManager>
MemberNrCcmRrcSapUser<C>::GetUeManager(uint16_t rnti)
{
    return m_owner->GetUeManager(rnti);
}
 
template <class C>
void
MemberNrCcmRrcSapUser<C>::SetNumberOfComponentCarriers(uint16_t noOfComponentCarriers)
{
    return m_owner->DoSetNumberOfComponentCarriers(noOfComponentCarriers);
}
 
} // end of namespace ns3
 
#endif /* NR_CCM_RRC_SAP_H */