bowComplexToken.h

Go to the documentation of this file.

// Copyright 2002-2020 CEA LIST
// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
/************************************************************************
 * @file     bowComplexToken.h
 * @author   Besancon Romaric
 * @date     Tue Oct  7 2003
 * copyright Copyright (C) 2003 by CEA LIST
 *
 * @brief
 *
 ***********************************************************************/
 
#ifndef BOWCOMPLEXTOKEN_H
#define BOWCOMPLEXTOKEN_H
 
#include "linguisticProcessing/LinguisticProcessingCommon.h"
#include "bowToken.h"
 
#include <boost/tuple/tuple.hpp>
#include <deque>
 
#include <boost/shared_ptr.hpp>
 
namespace Lima {
namespace Common {
namespace BagOfWords {
 
 
 
class BoWRelation;
 
class BoWComplexTokenPrivate;
class LIMA_BOW_EXPORT BoWComplexToken : public BoWToken
{
  friend class BoWComplexTokenPrivate;
public:
 
  class Part : public boost::tuple< boost::shared_ptr< BoWRelation >,
                                    boost::shared_ptr< BoWToken > >
  {
  public:
    Part() :
        boost::tuple< boost::shared_ptr< BoWRelation >,
                      boost::shared_ptr< BoWToken > >(boost::shared_ptr< BoWRelation >(),
                                                      boost::shared_ptr< BoWToken >() )
    {
    }
 
    Part(boost::shared_ptr< BoWToken > tok):
      boost::tuple< boost::shared_ptr< BoWRelation >,
                    boost::shared_ptr< BoWToken > >(boost::shared_ptr< BoWRelation >(),
                                                    tok)
    {
    }
 
    Part(boost::shared_ptr< BoWRelation > rel,
         boost::shared_ptr< BoWToken > tok) :
        boost::tuple< boost::shared_ptr< BoWRelation >,
                      boost::shared_ptr< BoWToken >>(rel,tok)
    {
    }
 
    boost::shared_ptr< BoWRelation > getBoWRelation() const { return get<0>(); }
 
    boost::shared_ptr< BoWToken > getBoWToken() const { return get<1>(); }
 
    LimaString getLemma() const { return get<1>()->getLemma(); }
 
    LinguisticCode getCategory() const { return get<1>()->getCategory(); }
  };
 
  BoWComplexToken();
//   /**
//    * copy constructor
//    *
//    * @attention the copy of the parts of a complex token is tricky :
//    * if a part of a complex token points to a token that have a proper
//    * existence outside of the part list, the pointer will be copied
//    * (no creation of a new object), otherwise a new object is created.
//    */
//   BoWComplexToken(const BoWComplexToken&);
//
//   /**
//    * specialized copy constructor that takes into account a
//    * pointer-to-pointer map giving the correspondance of tokens for
//    * the component list, in case of a complete BoWText copy.
//    *
//    */
//   BoWComplexToken(const BoWComplexToken&,
//                   const std::map<BoWToken*,BoWToken*>&);
 
  BoWComplexToken(const Lima::LimaString& lemma,
                  const LinguisticCode category,
                  const uint64_t position,
                  const uint64_t length);
 
  BoWComplexToken(const Lima::LimaString& lemma,
                  const LinguisticCode category,
                  const uint64_t position,
                  const uint64_t length,
                  std::deque< boost::shared_ptr< Lima::Common::BagOfWords::BoWToken > >& parts,
                  const uint64_t head);
 
  virtual ~BoWComplexToken();
 
//   virtual BoWComplexToken* clone() const;
//   virtual BoWComplexToken* clone(const std::map<BoWToken*,BoWToken*>&) const;
 
  virtual void clear() override;
 
  virtual Lima::LimaString getLemma(void) const override;
  virtual Lima::LimaString getInflectedForm(void) const override;
 
  BoWComplexToken& operator= (const BoWComplexToken&);
  bool operator== (const BoWComplexToken&);
 
  uint64_t size(void) const override;
 
  std::deque< Part >& getParts(void);
  const std::deque< Part >& getParts(void) const;
 
  std::deque< Part >::iterator getPartsIterator(void);
  const std::deque< Part >::const_iterator getPartsIterator(void) const;
 
  boost::shared_ptr< BoWToken > addPart(boost::shared_ptr< BoWToken > tok,
                                        const bool isHead=false);
 
  boost::shared_ptr< BoWToken > addPart(boost::shared_ptr< BoWRelation > rel,
                                        boost::shared_ptr< BoWToken > tok,
                                        const bool isHead=false);
 
//   BoWToken* addPart(const boost::shared_ptr< BoWToken > tok,
// //                     const bool isInList,
//                     const bool isHead=false);
 
//   BoWToken* addPart(const boost::shared_ptr< BoWRelation > rel,
//                     const boost::shared_ptr< BoWToken > tok,
// //                     const bool isInList,
//                     const bool isHead=false);
 
 
 
  uint64_t getHead() const;
  void setHead(const uint64_t);
 
  // this is an abstract class, has no type
  virtual BoWType getType() const override = 0;
 
  // common function for output of derived classes
  std::string getUTF8StringParts(const Common::PropertyCode::PropertyManager* macroManager = 0) const;
  std::string getstdstringParts() const;
 
  virtual Common::Misc::PositionLengthList getPositionLengthList() const override;
 
  void addToPosition(const uint64_t offset) override;
 
 
  virtual std::set< uint64_t > getVertices() const override;
 
protected:
    BoWComplexToken(BoWComplexTokenPrivate& d);
};
 
 
} // namespace BagOfWords
} // namespace Common
} // namespace Lima
 
#endif