tb_anchor_location.hpp

 
#ifndef TurtleBrains_AnchorLocation_hpp
#define TurtleBrains_AnchorLocation_hpp
 
#include <turtle_brains/core/tb_string_utilities.hpp>
#include <turtle_brains/core/tb_dynamic_structure.hpp>
 
namespace TurtleBrains::Graphics
{
 
    enum class Anchor
    {
        Center = 0,   
        TopLeft,      
        TopCenter,    
        TopRight,     
        CenterLeft,   
        CenterRight,  
        BottomLeft,   
        BottomCenter, 
        BottomRight,  
    };
 
    using AnchorLocation = Anchor;
 
    inline std::ostream& operator<<(std::ostream& output, const AnchorLocation& anchor)
    {
        switch (anchor)
        {
        case Anchor::Center: output << "center"; break;
        case Anchor::TopLeft: output << "top_left"; break;
        case Anchor::TopCenter: output << "top_center"; break;
        case Anchor::TopRight: output << "top_right"; break;
        case Anchor::CenterLeft: output << "center_left"; break;
        case Anchor::CenterRight: output << "center_right"; break;
        case Anchor::BottomLeft: output << "bottom_left"; break;
        case Anchor::BottomCenter: output << "bottom_center"; break;
        case Anchor::BottomRight: output << "bottom_right"; break;
        };
 
        return output;
    }
 
    inline std::istream& operator>>(std::istream& input, AnchorLocation& anchor)
    {
        tbCore::String anchorString;
        input >> anchorString;
        tbCore::StringUtilities::LowercaseInPlace(anchorString);
 
        if ("center" == anchorString) { anchor = Anchor::Center; }
        else if ("top_left" == anchorString || "topleft" == anchorString) { anchor = Anchor::TopLeft; }
        else if ("top_center" == anchorString || "topcenter" == anchorString) { anchor = Anchor::TopCenter; }
        else if ("top_right" == anchorString || "topright" == anchorString) { anchor = Anchor::TopRight; }
        else if ("center_left" == anchorString || "centerleft" == anchorString) { anchor = Anchor::CenterLeft; }
        else if ("center_right" == anchorString || "centerright" == anchorString) { anchor = Anchor::CenterRight; }
        else if ("bottom_left" == anchorString || "bottomleft" == anchorString) { anchor = Anchor::BottomLeft; }
        else if ("bottom_center" == anchorString || "bottomcenter" == anchorString) { anchor = Anchor::BottomCenter; }
        else if ("bottom_right" == anchorString || "bottomright" == anchorString) { anchor = Anchor::BottomRight; }
        else
        {
            tb_error("tbError: Unknown value '%s' to convert into an AnchorLocation.", anchorString.c_str());
            anchor = Anchor::TopLeft;
        }
 
        return input;
    }
 
    //inline void FromDynamicStructure(const DynamicStructure& data, AnchorLocation& anchor);
 
 
    //inline DynamicStructure ToDynamicStructure(const AnchorLocation& anchor)
    //{
    //  return tbCore::DynamicStructure(Core::ToString(anchor));
    //}
 
    //inline void FromDynamicStructure(const DynamicStructure& data, AnchorLocation& anchor)
    //{
    //  anchor = Core::FromString<AnchorLocation>(data.AsString());
    //}
 
    //template<typename Type> DynamicStructure ToDynamicStructure(const Type& object)
    //{
    //  return tbCore::ToDynamicStructure(object);
    //}
 
    //template<typename Type> Type FromDynamicStructure(const DynamicStructure& data)
    //{
    //  return tbCore::FromDynamicStructure(data);
    //}
 
    //template<> inline DynamicStructure ToDynamicStructure<AnchorLocation>(const AnchorLocation& anchor)
    //{
    //  return tbCore::DynamicStructure(Core::ToString(anchor));
    //}
 
    //template<> inline AnchorLocation FromDynamicStructure<AnchorLocation>(const DynamicStructure& data)
    //{
    //  return Core::FromString<AnchorLocation>(data.AsString());
    //}
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
// 2025-11-23: It doesn't feel right to extend the Core namespace like this from within the Graphics namespace or other
//   TurtleBrains kits, but, doing so is one possible solution to the other problem. Without extending the Core kit like
//   this we need to "re"define the ToDynamicStructure/FromDynamicStructure template within each individual namespace.
//   That seems easy enough if there is a single location, but as soon as we add a To/FromDynStruct to ColorPalette etc
//   then it becomes a little more tricky.
//
//   Upon writing this I think I stumbled on the brilliant idea of putting the initial Core::ToDynamicStructure directly
//   in the primary TurtleBrains namespace. DynamicStructure is Core enough that it exists there, so perhaps the template
//   could as well, which would solve the problem.  ...  Ackshually, you can't. Because the specializations must exist
//   in the same namespace as the template itself, meaning it can't jump into tbGraphics.
//
//   Though we could combine the ideas which means we extend TurtleBrains namespace with extra To/FromDyn structs rather
//   than TurtleBrains::Core, and I think that is at least slightly better than extending Core.
//
//   Currently the least bad way seems to be extending TurtleBrains namespace.
//
// 2025-11-23: ikiwixz came up with a solution using "tags" and "invoke_tag" which I renamed to Implements() in the
//   following: https://pastebin.com/VHEaYG2p which is based on https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1895r0.pdf
//   This seems like it punches through any of the namespace issues, but it is a little more convoluted to write because
//   the implementation needs to deal with the tags, that passes down to the game/project level too.
 
//namespace TurtleBrains::Core
//{
//  template<> inline DynamicStructure ToDynamicStructure<Graphics::AnchorLocation>(const Graphics::AnchorLocation& anchor)
//  {
//      return tbCore::DynamicStructure(Core::ToString(anchor));
//  }
//
//  template<> inline Graphics::AnchorLocation FromDynamicStructure<Graphics::AnchorLocation>(const DynamicStructure& data)
//  {
//      return Core::FromString<Graphics::AnchorLocation>(data.AsString());
//  }
//};
 
namespace TurtleBrains
{
    //Note: If we go this direction we need to move the ToDynamicStructure/FromDynamicStructure template functions into the
    //TurtleBrains namespace from within tb_dynamic_structure.hpp.
    template<> inline DynamicStructure ToDynamicStructure<Graphics::AnchorLocation>(const Graphics::AnchorLocation& anchor)
    {
        return DynamicStructure(Core::ToString(anchor));
    }
 
    template<> inline Graphics::AnchorLocation FromDynamicStructure<Graphics::AnchorLocation>(const DynamicStructure& data)
    {
        return Core::FromString<Graphics::AnchorLocation>(data.AsString());
    }
};
 
#endif /* TurtleBrains_AnchorLocation_hpp */