AbstractAccessIterators.h

Go to the documentation of this file.

// Copyright 2002-2013 CEA LIST
// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
/***************************************************************************
 *   Copyright (C) 2004-2012 by CEA LIST                      *
 *                                                                         *
 ***************************************************************************/
 
 
#ifndef LIMA_COMMON_ABSTRACTACCESSITERATORS_H
#define LIMA_COMMON_ABSTRACTACCESSITERATORS_H
 
#include "common/LimaCommon.h"
#include "common/Data/LimaString.h"
 
namespace Lima
{
namespace Common
{
 
class AbstractSubWordIterator
{
public:
  virtual const std::pair<uint64_t, uint64_t> operator*() const = 0;
  virtual AbstractSubWordIterator &operator++(int) = 0;
  virtual bool operator==(const AbstractSubWordIterator& it) const = 0;
  virtual bool operator!=(const AbstractSubWordIterator& it) const = 0;
  virtual ~AbstractSubWordIterator() {};
};
 
class AbstractSuperWordIterator
{
public:
  virtual const Lima::LimaString operator*() const = 0;
  virtual AbstractSuperWordIterator &operator++(int) = 0;
  virtual bool operator==(const AbstractSuperWordIterator& it) const = 0;
  virtual bool operator!=(const AbstractSuperWordIterator& it) const = 0;
  virtual ~AbstractSuperWordIterator() {};
};
 
 
typedef struct _approxSuggestion {
  LimaString word;
  int nbError;
} ApproxSuggestion;
 
class AbstractApproxWordIterator
{
public:
  virtual const Lima::Common::ApproxSuggestion operator*() const = 0;
  virtual AbstractApproxWordIterator &operator++(int) = 0;
  virtual bool operator==(const AbstractApproxWordIterator& it) const = 0;
  virtual bool operator!=(const AbstractApproxWordIterator& it) const = 0;
  virtual ~AbstractApproxWordIterator() {};
};
 
class ClonableSubWordIterator : public AbstractSubWordIterator 
{
public:
  virtual ClonableSubWordIterator* clone() const = 0;
};
 
class ClonableSuperWordIterator : public AbstractSuperWordIterator 
{
public:
  virtual ClonableSuperWordIterator* clone() const = 0;
};
 
class ClonableApproxWordIterator : public AbstractApproxWordIterator 
{
public:
  virtual ClonableApproxWordIterator* clone() const = 0;
};
 
class LIMA_COMMONMISC_EXPORT AccessSubWordIterator : public AbstractSubWordIterator
{
public:
  AccessSubWordIterator(ClonableSubWordIterator* delegate);
  AccessSubWordIterator(const AccessSubWordIterator& original);
  AccessSubWordIterator& operator=(const AccessSubWordIterator& original);
  virtual ~AccessSubWordIterator();
  
  virtual const std::pair<uint64_t, uint64_t> operator*() const override;
  virtual AbstractSubWordIterator &operator++(int) override;
  virtual bool operator==(const AbstractSubWordIterator& it) const override;
  virtual bool operator!=(const AbstractSubWordIterator& it) const override;
  
private:
  ClonableSubWordIterator* m_delegate;
};
 
 
inline const std::pair<uint64_t, uint64_t> AccessSubWordIterator::operator*() const {
  return m_delegate->operator*(); // clazy:exclude=rule-of-two-soft
}
 
inline AbstractSubWordIterator& AccessSubWordIterator::operator++(int i)
{
  return m_delegate->operator++(i);
}
 
inline bool AccessSubWordIterator::operator==(const AbstractSubWordIterator& it) const 
{
  const AccessSubWordIterator& asi=static_cast<const AccessSubWordIterator&>(it);
  return m_delegate->operator==(*(asi.m_delegate));
}
 
inline bool AccessSubWordIterator::operator!=(const AbstractSubWordIterator& it) const
{
  const AccessSubWordIterator& asi=static_cast<const AccessSubWordIterator&>(it);
  return m_delegate->operator!=(*(asi.m_delegate));
}
 
class LIMA_COMMONMISC_EXPORT AccessSuperWordIterator : public AbstractSuperWordIterator
{
public:
  AccessSuperWordIterator(ClonableSuperWordIterator* delegate);
  AccessSuperWordIterator(const AccessSuperWordIterator& original);
  AccessSuperWordIterator& operator=(const AccessSuperWordIterator& original);
  virtual ~AccessSuperWordIterator();
 
  virtual const Lima::LimaString operator*() const override;
  virtual AbstractSuperWordIterator &operator++(int) override;
  virtual bool operator==(const AbstractSuperWordIterator& it) const override;
  virtual bool operator!=(const AbstractSuperWordIterator& it) const override;
    
private:
  ClonableSuperWordIterator* m_delegate;
};
 
inline const Lima::LimaString AccessSuperWordIterator::operator*() const
{
  return m_delegate->operator*();
}
 
inline AbstractSuperWordIterator& AccessSuperWordIterator::operator++(int i)
{
  return m_delegate->operator++(i);
}
 
inline bool AccessSuperWordIterator::operator==(const AbstractSuperWordIterator& it) const
{
  const AccessSuperWordIterator& asi=static_cast<const AccessSuperWordIterator&>(it);
  return m_delegate->operator==(*(asi.m_delegate));
}
 
inline bool AccessSuperWordIterator::operator!=(const AbstractSuperWordIterator& it) const
{
  const AccessSuperWordIterator& asi=static_cast<const AccessSuperWordIterator&>(it);
  return m_delegate->operator!=(*(asi.m_delegate));
}
 
class LIMA_COMMONMISC_EXPORT AccessApproxWordIterator : public AbstractApproxWordIterator
{
public:
  AccessApproxWordIterator(ClonableApproxWordIterator* delegate);
  AccessApproxWordIterator(const AccessApproxWordIterator& original);
  AccessApproxWordIterator& operator=(const AccessApproxWordIterator& original);
  virtual ~AccessApproxWordIterator();
 
  virtual const Lima::Common::ApproxSuggestion operator*() const override;
  virtual AbstractApproxWordIterator &operator++(int) override;
  virtual bool operator==(const AbstractApproxWordIterator& it) const override;
  virtual bool operator!=(const AbstractApproxWordIterator& it) const override;
    
private:
  ClonableApproxWordIterator* m_delegate;
};
 
inline const Lima::Common::ApproxSuggestion AccessApproxWordIterator::operator*() const
{
  return m_delegate->operator*();
}
 
inline AbstractApproxWordIterator& AccessApproxWordIterator::operator++(int i)
{
  return m_delegate->operator++(i);
}
 
inline bool AccessApproxWordIterator::operator==(const AbstractApproxWordIterator& it) const
{
  const AccessApproxWordIterator& asi=static_cast<const AccessApproxWordIterator&>(it);
  return m_delegate->operator==(*(asi.m_delegate));
}
 
inline bool AccessApproxWordIterator::operator!=(const AbstractApproxWordIterator& it) const
{
  const AccessApproxWordIterator& asi=static_cast<const AccessApproxWordIterator&>(it);
  return m_delegate->operator!=(*(asi.m_delegate));
}
 
 
} // Common
} // Lima
 
#endif