Internal compiler error: Accessors for mapping with dynamically-sized keys not yet implemented

Question

I have a mapping(string => Person) public map:

struct Person {
        string name;
        string description;
        address primaryAddress;
        string linkToWebsite;
        string linkToPicture;
        address secondaryAddress;
        uint age;
}

, this struct is only made of strings, addresses and uints, but when compiling I get this error.

Internal compiler error: Accessors for mapping with dynamically-sized keys not yet implemented.

BUT,

From Solidity Features:

Strings as Mapping Keys

Strings are allowed as keys for mappings.

contract C {   mapping (string => uint) counter;   
function inc(string _s) { counter[_s]++; } }

Any help with it?

Answer 1

The thing was that my mapping was public, and there are no public accessors implemented for it yet. The solution is just to not declare the mapping as public.

Answer 2

Strings are allowed as keys in mapping. For example, this code works just fine testing in Pyethereum:

 from ethereum import tester as t

 code = '''
    contract Example {
       struct Person {
         string name;
       }
       mapping(string => Person) map;

       function setName(string name, string value) {
          map[name] = Person({name: value});
       }

       function getName(string key) constant returns (string) {
         return map[key].name;
       }

   }
  '''

   state = t.state()
   contract =  state.abi_contract(code, language='solidity')
   contract.setName('dave', 'hello')
   print contract.getName('dave')
   => 'hello'

There must be something going on in your actual contract code

Answer 3

without seeing your struct it's hard to guess, is this helping ?

contract structtestmapping {
    struct myStruct {
        uint id;
    }
    mapping(string => myStruct) mapmystruct;
    myStruct s = mapmystruct['mystring'];

}

your struct might contain dynamically sized elements as the code here suggests ?