kiid.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2020 Ian McInerney <[email protected]>
 * Copyright (C) 2007-2014 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright The KiCad Developers, see AUTHORS.TXT for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef KIID_H
#define KIID_H
 
#include <kicommon.h>
#include <boost/uuid/uuid.hpp>
#include <nlohmann/json_fwd.hpp>
 
#include <array>
#include <cstdint>
#include <string>
 
class wxString;

typedef uint32_t timestamp_t;
 
class KICOMMON_API KIID
{
public:
    KIID();
    KIID( int null );
    KIID( const std::string& aString );
    KIID( const char* aString );
    KIID( const wxString& aString );
    KIID( timestamp_t aTimestamp );
 
    void Clone( const KIID& aUUID );
 
    size_t Hash() const;

    static KIID FromName( const std::string& aName );
    static KIID FromBytes( const std::array<uint8_t, 16>& aBytes );
 
    bool        IsLegacyTimestamp() const;
    timestamp_t AsLegacyTimestamp() const;
 
    wxString                AsString() const;
    wxString                AsLegacyTimestampString() const;
    std::string             AsStdString() const;
    std::array<uint8_t, 16> AsBytes() const;

    static bool SniffTest( const wxString& aCandidate );

    static void CreateNilUuids( bool aNil = true );

    static void SeedGenerator( unsigned int aSeed );

    void ConvertTimestampToUuid();

    static KIID Combine( const KIID& aFirst, const KIID& aSecond );

    static KIID FromDeterministicString( const wxString& aName );

    void Increment();
 
    bool operator==( KIID const& rhs ) const
    {
        return m_uuid == rhs.m_uuid;
    }
 
    bool operator!=( KIID const& rhs ) const
    {
        return m_uuid != rhs.m_uuid;
    }
 
    bool operator<( KIID const& rhs ) const
    {
        return m_uuid < rhs.m_uuid;
    }
 
    bool operator>( KIID const& rhs ) const
    {
        return m_uuid > rhs.m_uuid;
    }
 
private:
    boost::uuids::uuid m_uuid;
};
 
 
extern KICOMMON_API KIID niluuid;
 
KICOMMON_API KIID& NilUuid();
 
class KICOMMON_API KIID_PATH : public std::vector<KIID>
{
public:
    KIID_PATH() {}
 
    KIID_PATH( const wxString& aString );
 
    bool MakeRelativeTo( const KIID_PATH& aPath );

    bool EndsWith( const KIID_PATH& aPath ) const;
 
    bool IsContainedWithin( const KIID_PATH& aParentPath ) const
    {
        return size() >= aParentPath.size() && std::equal( aParentPath.begin(), aParentPath.end(), begin() );
    }
 
    wxString AsString() const;
 
    bool operator==( KIID_PATH const& rhs ) const
    {
        if( size() != rhs.size() )
            return false;
 
        for( size_t i = 0; i < size(); ++i )
        {
            if( at( i ) != rhs.at( i ) )
                return false;
        }
 
        return true;
    }
 
    bool operator<( KIID_PATH const& rhs ) const
    {
        if( size() != rhs.size() )
            return size() < rhs.size();
 
        for( size_t i = 0; i < size(); ++i )
        {
            if( at( i ) < rhs.at( i ) )
                return true;
 
            if( at( i ) != rhs.at( i ) )
                return false;
        }
 
        return false;
    }
 
    bool operator>( KIID_PATH const& rhs ) const
    {
        if( size() != rhs.size() )
            return size() > rhs.size();
 
        for( size_t i = 0; i < size(); ++i )
        {
            if( at( i ) > rhs.at( i ) )
                return true;
 
            if( at( i ) != rhs.at( i ) )
                return false;
        }
 
        return false;
    }
 
    KIID_PATH& operator+=( const KIID_PATH& aRhs )
    {
        for( const KIID& kiid : aRhs )
            emplace_back( kiid );
 
        return *this;
    }
 
    friend KIID_PATH operator+( KIID_PATH aLhs, const KIID_PATH& aRhs )
    {
        aLhs += aRhs;
        return aLhs;
    }
};

class KICOMMON_API KIID_NIL_SET_RESET
{
public:
    KIID_NIL_SET_RESET() { KIID::CreateNilUuids( true ); };
 
    ~KIID_NIL_SET_RESET() { KIID::CreateNilUuids( false ); }
};
 
KICOMMON_API void to_json( nlohmann::json& aJson, const KIID& aKIID );
 
KICOMMON_API void from_json( const nlohmann::json& aJson, KIID& aKIID );
 
template <>
struct KICOMMON_API std::hash<KIID>
{
    std::size_t operator()( const KIID& aId ) const { return aId.Hash(); }
};
 
 
template <>
struct std::hash<KIID_PATH>
{
    std::size_t operator()( const KIID_PATH& aPath ) const
    {
        std::size_t seed = 0;
 
        for( const KIID& kiid : aPath )
            seed ^= std::hash<KIID>()( kiid ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
 
        return seed;
    }
};
 
#endif // KIID_H